path: root/test/ratnest-tests.adb

with

    Ada.Characters.Latin_1,
    Ada.Strings.Maps,
    Ada.Exceptions,
    Packrat.Lexer.Debug,
    Packrat.Graphs,
    Packrat.Util;


package body Ratnest.Tests is


    package Latin renames Ada.Characters.Latin_1;
    package Strmaps renames Ada.Strings.Maps;
    package Except renames Ada.Exceptions;
    package PE renames Packrat.Errors;
    package PU renames Packrat.Util;





    package body Errors is


        function Valid_Message_Check
            return Test_Result is
        begin
            if  PE.Valid_Message ("abcde") or PE.Valid_Message ("sSYM") or
                PE.Valid_Message ("sSYMp") or PE.Valid_Message ("p345") or
                PE.Valid_Message ("pOne") or PE.Valid_Message ("sSYMp1sNEXT") or
                PE.Valid_Message ("sSYMp1.2") or PE.Valid_Message ("sABcDp12") or
                not PE.Valid_Message ("sSYMp0") or not PE.Valid_Message ("sAp12") or
                not PE.Valid_Message ("sNAMEp34sSYMp02") or not PE.Valid_Message ("") or
                not PE.Valid_Message ("sA_Bp3") or not PE.Valid_Message ("sAp1sAp1")
            then
                return Fail;
            end if;
            return Pass;
        end Valid_Message_Check;


        function Valid_Identifier_Check
            return Test_Result
        is
            Pass_Array : PE.Error_Info_Array :=
                ((+"A", 1), (+"ABC", 2), (+"AB_CD", 3), (+"A_B_CD", 4));
            Fail_Array : PE.Error_Info_Array :=
                ((+"_", 1), (+"_A", 2), (+"A_", 3), (+"A__B", 4), (+"A%B", 3));
        begin
            for EI of Pass_Array loop
                if  not PE.Valid_Identifier (EI.Symbol) or
                    not PE.Valid_Identifier (-EI.Symbol)
                then
                    return Fail;
                end if;
            end loop;
            for EI of Fail_Array loop
                if  PE.Valid_Identifier (EI.Symbol) or
                    PE.Valid_Identifier (-EI.Symbol)
                then
                    return Fail;
                end if;
            end loop;
            if  not PE.Valid_Identifier_Array (Pass_Array) or
                PE.Valid_Identifier_Array (Fail_Array)
            then
                return Fail;
            end if;
            return Pass;
        end Valid_Identifier_Check;


        function Join_Check
            return Test_Result
        is
            Array_1 : PE.Error_Info_Array := ((+"A", 1), (+"B", 2));
            Msg_1 : PE.Error_Message := PE.Encode_Array (Array_1);

            Array_2 : PE.Error_Info_Array := ((+"C", 3), (+"D", 4));
            Msg_2 : PE.Error_Message := PE.Encode_Array (Array_2);

            Msg_3 : PE.Error_Message := PE.Join (Msg_1, Msg_2);

            Array_4 : PE.Error_Info_Array := ((+"A", 1), (+"B", 2), (+"C", 3), (+"D", 4));
            Msg_4 : PE.Error_Message := PE.Encode_Array (Array_4);

            Array_5 : PE.Error_Info_Array := ((+"A", 1), (+"B", 4));
            Msg_5 : PE.Error_Message := PE.Encode_Array (Array_5);

            Array_6 : PE.Error_Info_Array := ((+"A", 1), (+"C", 3));
            Msg_6 : PE.Error_Message := PE.Encode_Array (Array_6);

            Msg_7 : PE.Error_Message := PE.Join (Msg_5, Msg_6);

            Array_8 : PE.Error_Info_Array := ((+"A", 1), (+"B", 4), (+"C", 3));
            Msg_8 : PE.Error_Message := PE.Encode_Array (Array_8);
        begin
            if Msg_3 /= Msg_4 or Msg_7 /= Msg_8 then
                return Fail;
            end if;
            return Pass;
        end Join_Check;


        function Encode_1_Check
            return Test_Result is
        begin
            --  Encode with a String and a Natural
            if PE.Encode ("ABC", 15) /= "sABCp15" then
                return Fail;
            end if;
            return Pass;
        end Encode_1_Check;


        function Encode_2_Check
            return Test_Result is
        begin
            --  Encode with an Unbounded_String and a Natural
            if PE.Encode (+"ABC", 15) /= "sABCp15" then
                return Fail;
            end if;
            return Pass;
        end Encode_2_Check;


        function Encode_3_Check
            return Test_Result is
        begin
            --  Encode with an Error_Info
            if PE.Encode ((+"ABC", 15)) /= "sABCp15" then
                return Fail;
            end if;
            return Pass;
        end Encode_3_Check;


        function Encode_4_Check
            return Test_Result is
        begin
            --  Encode with an Error_Info_Array
            if  PE.Encode_Array (((+"A", 3), (+"BC", 2), (+"ABC", 1), (+"B", 4))) /=
                "sAp3sBCp2sABCp1sBp4"
            then
                return Fail;
            end if;
            return Pass;
        end Encode_4_Check;


        function Decode_Check
            return Test_Result
        is
            use type PE.Error_Info_Array;
        begin
            if PE.Decode ("sAp1sBp3sCp10sDEFp456") /=
                ((+"A", 1), (+"B", 3), (+"C", 10), (+"DEF", 456))
            then
                return Fail;
            end if;
            return Pass;
        end Decode_Check;


    end Errors;





    package body Tokens is


        type My_Labels is (One, Two, Three);
        package My_Tokens is new Packrat.Tokens (My_Labels, Character, String);


        function Adjust_Check
            return Test_Result
        is
            A : My_Tokens.Token;
        begin
            declare
                B : My_Tokens.Token := My_Tokens.Create (One, 1, 3, "abc");
            begin
                A := B;
            end;
            if not A.Initialized or else A.Value /= "abc" then
                return Fail;
            end if;
            return Pass;
        end Adjust_Check;


        function Equals_Check
            return Test_Result
        is
            use type My_Tokens.Token;
            A : My_Tokens.Token := My_Tokens.Create (One, 1, 3, "abc");
            B : My_Tokens.Token := My_Tokens.Create (One, 1, 3, "abc");
        begin
            if A /= B then
                return Fail;
            end if;
            return Pass;
        end Equals_Check;


        function Store_Check
            return Test_Result
        is
            T : My_Tokens.Token := My_Tokens.Create (One, 1, 3, "abc");
        begin
            if  not T.Initialized or else
                T.Label /= One or else
                T.Start /= 1 or else T.Finish /= 3 or else
                T.Value /= "abc"
            then
                return Fail;
            end if;
            return Pass;
        end Store_Check;


    end Tokens;





    package body Lexer is


        type My_Labels is (One, Two, Three);


        package String_Tokens is new Packrat.Tokens (My_Labels, Character, String);
        package Slexy is new Packrat.Lexer (My_Labels, Character, String, String_Tokens);
        package Slebug is new Slexy.Debug;


        use type Slexy.Combinator_Result;





        function Join_Check
            return Test_Result
        is
            One    : Slexy.Combinator_Result :=
                Slebug.Create_Result (1, Packrat.Success);
            Two    : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Three  : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);

            Four   : Slexy.Combinator_Result :=
                Slebug.Create_Result (4, Packrat.Failure);
            Five   : Slexy.Combinator_Result :=
                Slebug.Create_Result (4, Packrat.Failure);

            Six    : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Needs_More);
            Seven  : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Needs_More);

            Eight  : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Failure);

            Nine   : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Optional_More);
            Ten    : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Eleven : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
        begin
            if  Slebug.Join (One, Two) /= Three or Slebug.Join (One, Four) /= Five or
                Slebug.Join (One, Six) /= Seven or Slebug.Join (Four, Six) /= Four or
                Slebug.Join (Five, Two) /= Five or Slebug.Join (Six, Three) /= Eight or
                Slebug.Join (Slebug.Empty_Fail, One) /= Slebug.Empty_Fail or
                Slebug.Join (Nine, Ten) /= Eleven
            then
                return Fail;
            end if;
            return Pass;
        end Join_Check;


        function Equals_Check
            return Test_Result
        is
            One : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Two : Slexy.Combinator_Result :=
                Slebug.Create_Result (0, Packrat.Failure);
        begin
            if One = Two or Two /= Slebug.Empty_Fail then
                return Fail;
            end if;
            return Pass;
        end Equals_Check;





        function Sequence_Check
            return Test_Result
        is
            function Match_A is new Slexy.Match ('a');
            function Match_B is new Slexy.Match ('b');
            function Match_C is new Slexy.Match ('c');
            function Seq_Abc is new Slexy.Sequence
              ((Match_A'Unrestricted_Access,
                Match_B'Unrestricted_Access,
                Match_C'Unrestricted_Access));

            Test_Str : String := "aababcabcab";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (1, Packrat.Failure);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (11, Packrat.Needs_More);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (6, Packrat.Success);
            Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail;
            Result5 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Failure);
        begin
            if  Seq_Abc (Test_Str, 1) /= Result1 or Seq_Abc (Test_Str, 2) /= Result5 or
                Seq_Abc (Test_Str, 4) /= Result3 or Seq_Abc (Test_Str, 10) /= Result2 or
                Seq_Abc (Test_Str, 3) /= Result4 or
                Seq_Abc (Test_Str, Test_Str'Last + 5) /= Result4
            then
                return Fail;
            end if;
            return Pass;
        end Sequence_Check;


        function Count_Check
            return Test_Result
        is
            function Match_A is new Slexy.Match ('a');
            function Match_B is new Slexy.Match ('b');
            function Count_2A is new Slexy.Count (Match_A, 2);
            function Count_3B is new Slexy.Count (Match_B, 3);

            Test_Str : String := "abaabbaaabbbaaaabbbb";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (1, Packrat.Failure);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (4, Packrat.Success);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (2, Packrat.Failure);
            Result4 : Slexy.Combinator_Result :=
                Slebug.Create_Result (20, Packrat.Needs_More);
            Result5 : Slexy.Combinator_Result :=
                Slebug.Create_Result (12, Packrat.Success);
            Result6 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Count_2A (Test_Str, 1) /= Result1 or Count_2A (Test_Str, 3) /= Result2 or
                Count_3B (Test_Str, 2) /= Result3 or Count_3B (Test_Str, 19) /= Result4 or
                Count_3B (Test_Str, 10) /= Result5 or Count_3B (Test_Str, 1) /= Result6 or
                Count_2A (Test_Str, 2) /= Result6 or
                Count_2A (Test_Str, Test_Str'Last + 5) /= Result6
            then
                return Fail;
            end if;
            return Pass;
        end Count_Check;


        function Many_Check
            return Test_Result
        is
            function Match_A is new Slexy.Match ('a');
            function Many_0 is new Slexy.Many (Match_A);
            function Many_4 is new Slexy.Many (Match_A, 4);

            function Match_B is new Slexy.Match ('b');
            function Match_C is new Slexy.Match ('c');
            function Seq_Abc is new Slexy.Sequence
              ((Match_A'Unrestricted_Access,
                Match_B'Unrestricted_Access,
                Match_C'Unrestricted_Access));
            function Many_Seq_0 is new Slexy.Many (Seq_Abc);
            function Many_Seq_4 is new Slexy.Many (Seq_Abc, 4);

            Test_Str  : String := "aaabbaaaaabaa";
            Test_Str2 : String := "aababcabcab";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (13, Packrat.Optional_More);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (10, Packrat.Success);
            Result4 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Failure);
            Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail;
            Result6 : Slexy.Combinator_Result :=
                Slebug.Create_Result (13, Packrat.Needs_More);
            Result7 : Slexy.Combinator_Result :=
                Slebug.Create_Result (0, Packrat.Success);
            Result8 : Slexy.Combinator_Result :=
                Slebug.Create_Result (9, Packrat.Optional_More);
            Result9 : Slexy.Combinator_Result :=
                Slebug.Create_Result (9, Packrat.Needs_More);
        begin
            if  Many_0 (Test_Str, 1) /= Result1 or Many_4 (Test_Str, 1) /= Result4 or
                Many_4 (Test_Str, 6) /= Result3 or Many_0 (Test_Str, 4) /= Result7 or
                Many_0 (Test_Str, 12) /= Result2 or Many_4 (Test_Str, 12) /= Result6 or
                Many_0 (Test_Str, Test_Str'Last + 5) /= Result5 or
                Many_Seq_0 (Test_Str2, 4) /= Result8 or Many_Seq_4 (Test_Str2, 4) /= Result9
            then
                return Fail;
            end if;
            return Pass;
        end Many_Check;


        function Many_Until_Check
            return Test_Result
        is
            function Match_A is new Slexy.Match ('a');
            function Many_Until_0 is new Slexy.Many_Until (Match_A, PU.Is_Digit);
            function Many_Until_3 is new Slexy.Many_Until (Match_A, PU.Is_Digit, 3);

            Test_Str : String := "aaaabbaaa123aaa";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (4, Packrat.Failure);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (9, Packrat.Success);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (15, Packrat.Needs_More);
            Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Many_Until_0 (Test_Str, 1) /= Result1 or
                Many_Until_0 (Test_Str, 7) /= Result2 or
                Many_Until_3 (Test_Str, 7) /= Result2 or
                Many_Until_3 (Test_Str, 13) /= Result3 or
                Many_Until_0 (Test_Str, 5) /= Result4 or
                Many_Until_0 (Test_Str, Test_Str'Last + 5) /= Result4 or
                Many_Until_3 (Test_Str, Test_Str'Last + 5) /= Result4
            then
                return Fail;
            end if;
            return Pass;
        end Many_Until_Check;


        function Satisfy_Check
            return Test_Result
        is
            function Is_123
                   (Char : in Character)
                return Boolean is
            begin
                return Char = '1' or Char = '2' or Char = '3';
            end Is_123;
            function Is_Abc
                   (Char : in Character)
                return Boolean is
            begin
                return Char = 'a' or Char = 'b' or Char = 'c';
            end Is_Abc;

            function Satisfy_123 is new Slexy.Satisfy (Is_123);
            function Satisfy_Abc is new Slexy.Satisfy (Is_Abc);

            Test_Str : String := "abc123456def";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (2, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (6, Packrat.Success);
            Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Satisfy_123 (Test_Str, 6) /= Result2 or
                Satisfy_Abc (Test_Str, 2) /= Result1 or
                Satisfy_Abc (Test_Str, 8) /= Result3 or
                Satisfy_123 (Test_Str, Test_Str'Last + 5) /= Result3
            then
                return Fail;
            end if;
            return Pass;
        end Satisfy_Check;


        function Satisfy_With_Check
            return Test_Result
        is
            function Is_Abc
                   (Char : in Character)
                return Boolean is
            begin
                return Char = 'a' or Char = 'b' or Char = 'c';
            end Is_Abc;
            function Is_123
                   (Char : in Character)
                return Boolean is
            begin
                return Char = '1' or Char = '2' or Char = '3';
            end Is_123;
            function Minus_One
                   (Char : in Character)
                return Character is
            begin
                return Character'Val (Character'Pos (Char) - 1);
            end Minus_One;

            function Satisfy_Bcd is new Slexy.Satisfy_With (Is_Abc, Minus_One);
            function Satisfy_234 is new Slexy.Satisfy_With (Is_123, Minus_One);

            Test_Str : String := "abcde12345";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (7, Packrat.Success);
            Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Satisfy_Bcd (Test_Str, 3) /= Result1 or
                Satisfy_234 (Test_Str, 7) /= Result2 or
                Satisfy_Bcd (Test_Str, 1) /= Result3 or
                Satisfy_234 (Test_Str, Test_Str'Last + 5) /= Result3
            then
                return Fail;
            end if;
            return Pass;
        end Satisfy_With_Check;


        function Match_Check
            return Test_Result
        is
            function Match_A is new Slexy.Match ('a');
            function Match_Slash is new Slexy.Match ('/');
            function Match_4 is new Slexy.Match ('4');

            Test_Str : String := "abc1234./5";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (1, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (9, Packrat.Success);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (7, Packrat.Success);
            Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Match_A (Test_Str, 1) /= Result1 or
                Match_Slash (Test_Str, 9) /= Result2 or
                Match_4 (Test_Str, 7) /= Result3 or
                Match_A (Test_Str, 3) /= Result4 or
                Match_A (Test_Str, Test_Str'Last + 5) /= Result4
            then
                return Fail;
            end if;
            return Pass;
        end Match_Check;


        function Match_With_Check
            return Test_Result
        is
            function Plus_One
                   (Char : in Character)
                return Character is
            begin
                return Character'Val (Character'Pos (Char) + 1);
            end Plus_One;

            function Match_A is new Slexy.Match_With ('b', Plus_One);
            function Match_6 is new Slexy.Match_With ('7', Plus_One);

            Test_Str : String := "abc5678";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (1, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Match_A (Test_Str, 1) /= Result1 or
                Match_6 (Test_Str, 5) /= Result2 or
                Match_A (Test_Str, 2) /= Result3 or
                Match_A (Test_Str, Test_Str'Last + 5) /= Result3
            then
                return Fail;
            end if;
            return Pass;
        end Match_With_Check;


        function Multimatch_Check
            return Test_Result
        is
            function Match_String1 is new Slexy.Multimatch ("abc");
            function Match_String2 is new Slexy.Multimatch ("hello");

            Test_Str : String := "abcdefabhelloworldab";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (20, Packrat.Needs_More);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (13, Packrat.Success);
            Result4 : Slexy.Combinator_Result :=
                Slebug.Create_Result (8, Packrat.Failure);
            Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Match_String1 (Test_Str, 1) /= Result1 or
                Match_String1 (Test_Str, 7) /= Result4 or
                Match_String2 (Test_Str, 9) /= Result3 or
                Match_String2 (Test_Str, 3) /= Result5 or
                Match_String1 (Test_Str, 19) /= Result2 or
                Match_String1 (Test_Str, Test_Str'Last + 5) /= Result5
            then
                return Fail;
            end if;
            return Pass;
        end Multimatch_Check;


        function Take_Check
            return Test_Result
        is
            function Take_1 is new Slexy.Take;
            function Take_5 is new Slexy.Take (5);

            Test_Str : String := "abcdefghi";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (2, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (9, Packrat.Needs_More);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (7, Packrat.Success);
            Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Take_1 (Test_Str, 2) /= Result1 or Take_5 (Test_Str, 7) /= Result2 or
                Take_5 (Test_Str, 3) /= Result3 or
                Take_1 (Test_Str, Test_Str'Last + 5) /= Result4
            then
                return Fail;
            end if;
            return Pass;
        end Take_Check;


        function Take_While_Check
            return Test_Result
        is
            function Take_Letters is new Slexy.Take_While (PU.Is_Letter);
            function Take_Punch is new Slexy.Take_While (PU.Is_Punctuation);
            function Take_Digits is new Slexy.Take_While (PU.Is_Digit);

            Test_Str : String := "abcde,./;'fghi[]=-^563";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (14, Packrat.Success);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (10, Packrat.Success);
            Result4 : Slexy.Combinator_Result :=
                Slebug.Create_Result (19, Packrat.Success);
            Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail;
            Result6 : Slexy.Combinator_Result :=
                Slebug.Create_Result (22, Packrat.Optional_More);
        begin
            if  Take_Letters (Test_Str, 2) /= Result1 or
                Take_Letters (Test_Str, 13) /= Result2 or
                Take_Punch (Test_Str, 6) /= Result3 or
                Take_Punch (Test_Str, 17) /= Result4 or
                Take_Letters (Test_Str, 7) /= Result5 or
                Take_Punch (Test_Str, Test_Str'Last + 5) /= Result5 or
                Take_Digits (Test_Str, 20) /= Result6
            then
                return Fail;
            end if;
            return Pass;
        end Take_While_Check;


        function Take_Until_Check
            return Test_Result
        is
            function Take_Till_Punch is new Slexy.Take_Until (PU.Is_Punctuation);
            function Take_Till_Digit is new Slexy.Take_Until (PU.Is_Digit);

            Test_Str : String := "abcde12345;;;fghi67";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (10, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (19, Packrat.Optional_More);
            Result3 : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Result4 : Slexy.Combinator_Result :=
                Slebug.Create_Result (17, Packrat.Success);
            Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  Take_Till_Punch (Test_Str, 4) /= Result1 or
                Take_Till_Punch (Test_Str, 16) /= Result2 or
                Take_Till_Digit (Test_Str, 1) /= Result3 or
                Take_Till_Digit (Test_Str, 12) /= Result4 or
                Take_Till_Punch (Test_Str, 11) /= Result5 or
                Take_Till_Punch (Test_Str, Test_Str'Last + 5) /= Result5
            then
                return Fail;
            end if;
            return Pass;
        end Take_Until_Check;


        function Line_End_Check
            return Test_Result
        is
            function LF_End is new Slexy.Line_End (Latin.LF);
            function C_End is new Slexy.Line_End ('c');

            Test_Str : String := "abcd" & Latin.LF & "e";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  LF_End (Test_Str, 5) /= Result1 or C_End (Test_Str, 3) /= Result2 or
                LF_End (Test_Str, Test_Str'Last + 5) /= Result3 or LF_End (Test_Str, 1) /= Result3
            then
                return Fail;
            end if;
            return Pass;
        end Line_End_Check;


        function Input_End_Check
            return Test_Result
        is
            function C_End is new Slexy.Input_End ('c');
            function E_End is new Slexy.Input_End ('e');

            Test_Str : String := "abcde";

            Result1 : Slexy.Combinator_Result :=
                Slebug.Create_Result (5, Packrat.Success);
            Result2 : Slexy.Combinator_Result :=
                Slebug.Create_Result (3, Packrat.Success);
            Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail;
        begin
            if  C_End (Test_Str, 3) /= Result2 or E_End (Test_Str, 5) /= Result1 or
                C_End (Test_Str, 6) /= Result3 or E_End (Test_Str, 6) /= Result3 or
                C_End (Test_Str, 1) /= Result3 or E_End (Test_Str, Test_Str'Last + 5) /= Result3
            then
                return Fail;
            end if;
            return Pass;
        end Input_End_Check;





        function Stamp_Check
            return Test_Result
        is
            use type String_Tokens.Token;
            use type Packrat.Result_Status;
            use type Slexy.Component_Result;

            function Match_A is new Slexy.Match ('a');
            function Match_B is new Slexy.Match ('b');
            function Match_C is new Slexy.Match ('c');
            function Seq_Abc is new Slexy.Sequence
              ((Match_A'Unrestricted_Access,
                Match_B'Unrestricted_Access,
                Match_C'Unrestricted_Access));
            function My_Stamp is new Slexy.Stamp (One, Seq_Abc);

            Test_Str1 : String := "abcdefghi";
            Test_Str2 : String := "ab";

            Context1 : Slexy.Lexer_Context := Slexy.Empty_Context;
            Context2 : Slexy.Lexer_Context := Slexy.Empty_Context;

            Comp_Code : Slexy.Component_Result;
        begin
            Comp_Code := My_Stamp (Test_Str1, Context1);
            if (Slebug.So_Far (Context1).Length /= 1 or else
                Slebug.So_Far (Context1).Element (1) /= String_Tokens.Create (One, 1, 3, "abc")) or
                Slebug.Position (Context1) /= 4 or Slebug.Status (Context1) /= Packrat.Success or
                Slebug.Pass (Context1) /= null
            then
                return Fail;
            end if;
            Comp_Code := My_Stamp (Test_Str1, Context1);
            if (Slebug.So_Far (Context1).Length /= 1 or else
                Slebug.So_Far (Context1).Element (1) /= String_Tokens.Create (One, 1, 3, "abc")) or
                Slebug.Position (Context1) /= 4 or not Slebug.Is_Failure (Comp_Code) or
                Slebug.Pass (Context1) /= null
            then
                return Fail;
            end if;
            Comp_Code := My_Stamp (Test_Str2, Context2);
            if  Slebug.So_Far (Context2).Length /= 0 or
                Slebug.Position (Context2) /= 1 or
                Slebug.Status (Context2) /= Packrat.Needs_More or
               (Slebug.Pass (Context2) = null or else Slebug.Pass (Context2).all /= "ab")
            then
                return Fail;
            end if;
            return Pass;
        end Stamp_Check;


        function Ignore_Check
            return Test_Result
        is
            use type Packrat.Result_Status;

            function Match_Abc is new Slexy.Multimatch ("abc");
            function My_Ignore is new Slexy.Ignore (Two, Match_Abc);

            Test_Str1 : String := "abcdefghi";
            Test_Str2 : String := "ab";

            Context1 : Slexy.Lexer_Context := Slexy.Empty_Context;
            Context2 : Slexy.Lexer_Context := Slexy.Empty_Context;

            Comp_Code : Slexy.Component_Result;
        begin
            Comp_Code := My_Ignore (Test_Str1, Context1);
            if  Slebug.So_Far (Context1).Length /= 0 or
                Slebug.Position (Context1) /= 4 or Slebug.Status (Context1) /= Packrat.Success or
                Slebug.Pass (Context1) /= null
            then
                return Fail;
            end if;
            Comp_Code := My_Ignore (Test_Str1, Context1);
            if  Slebug.So_Far (Context1).Length /= 0 or
                Slebug.Position (Context1) /= 4 or not Slebug.Is_Failure (Comp_Code) or
                Slebug.Pass (Context1) /= null
            then
                return Fail;
            end if;
            Comp_Code := My_Ignore (Test_Str2, Context2);
            if  Slebug.So_Far (Context2).Length /= 0 or
                Slebug.Position (Context2) /= 1 or Slebug.Status (Context2) /= Packrat.Needs_More or
               (Slebug.Pass (Context2) = null or else Slebug.Pass (Context2).all /= "ab")
            then
                return Fail;
            end if;
            return Pass;
        end Ignore_Check;





        type Word_Enum is (Blank, Word, Whitespace);

        package Word_Tokens is new Packrat.Tokens (Word_Enum, Character, String);
        package Swordy is new Packrat.Lexer (Word_Enum, Character, String, Word_Tokens);
        package Swolbug is new Swordy.Debug;

        use type Word_Tokens.Token;
        use type Word_Tokens.Token_Array;

        function Satisfy_Letter is new Swordy.Satisfy (PU.Is_Letter);
        function Many_Letter is new Swordy.Many (Satisfy_Letter, 1);
        function Satisfy_Whitespace is new Swordy.Satisfy (PU.Is_Whitespace);
        function Many_Whitespace is new Swordy.Many (Satisfy_Whitespace, 1);

        function Stamp_Word is new Swordy.Stamp (Word, Many_Letter);
        function Ignore_Whitespace is new Swordy.Ignore (Whitespace, Many_Whitespace);


        function Scan_Check
            return Test_Result
        is
            function My_Scan is new Swordy.Scan
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Str : String := "one fine day";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Intended_Result1 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 1, 3, "one"),
                2 => Word_Tokens.Create (Word, 5, 8, "fine"));
            Intended_Result2 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 10, 12, "day"));

            Actual_Result1 : Word_Tokens.Token_Array :=
                My_Scan (Test_Str, Test_Context);
            Actual_Result2 : Word_Tokens.Token_Array :=
                My_Scan ("", Test_Context);
        begin
            if Actual_Result1 /= Intended_Result1 or Actual_Result2 /= Intended_Result2 then
                return Fail;
            end if;
            return Pass;
        end Scan_Check;


        function Scan_Only_Check
            return Test_Result
        is
            function My_Scan is new Swordy.Scan_Only
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Str : String := "one fine day";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Intended_Result : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 1, 3, "one"),
                2 => Word_Tokens.Create (Word, 5, 8, "fine"),
                3 => Word_Tokens.Create (Word, 10, 12, "day"));

            Actual_Result : Word_Tokens.Token_Array :=
                My_Scan (Test_Str, Test_Context);
        begin
            if Actual_Result /= Intended_Result then
                return Fail;
            end if;
            return Pass;
        end Scan_Only_Check;


        function Scan_With_Check
            return Test_Result
        is
            Sentinel : Natural := 2;
            function More_Input
                return String is
            begin
                if Sentinel > 1 then
                    Sentinel := 1;
                    return "it will happen  again";
                elsif Sentinel > 0 then
                    Sentinel := 0;
                    return " and again and again";
                else
                    return "";
                end if;
            end More_Input;

            function My_Scan is new Swordy.Scan_With
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Intended_Result : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 1, 2, "it"),
                2 => Word_Tokens.Create (Word, 4, 7, "will"),
                3 => Word_Tokens.Create (Word, 9, 14, "happen"),
                4 => Word_Tokens.Create (Word, 17, 21, "again"),
                5 => Word_Tokens.Create (Word, 23, 25, "and"),
                6 => Word_Tokens.Create (Word, 27, 31, "again"),
                7 => Word_Tokens.Create (Word, 33, 35, "and"),
                8 => Word_Tokens.Create (Word, 37, 41, "again"));

            Actual_Result : Word_Tokens.Token_Array :=
                My_Scan (More_Input'Unrestricted_Access, Test_Context);
        begin
            if Actual_Result /= Intended_Result then
                return Fail;
            end if;
            return Pass;
        end Scan_With_Check;


        function Scan_Set_Check
            return Test_Result
        is
            procedure My_Scan is new Swordy.Scan_Set
               ((Stamp_Word'Access, Ignore_Whitespace'Access),
                Latin.EOT, Word_Tokens.Create (Blank, 1, 0, ""));

            Test_Str1 : String (1 .. 10) := "one     tw";
            Test_Str2 : String (1 .. 10) := "o    three";
            Test_Str3 : String (1 .. 10) := Latin.EOT & "         ";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Intended_Result1 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 1, 3, "one"),
                2 => Word_Tokens.Create (Blank, 1, 0, ""));
            Intended_Result2 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 9, 11, "two"),
                2 => Word_Tokens.Create (Blank, 1, 0, ""));
            Intended_Result3 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 16, 20, "three"),
                2 => Word_Tokens.Create (Blank, 1, 0, ""));

            Actual_Result : Word_Tokens.Token_Array (1 .. 2);
        begin
            My_Scan (Test_Str1, Test_Context, Actual_Result);
            if Actual_Result /= Intended_Result1 then
                return Fail;
            end if;
            My_Scan (Test_Str2, Test_Context, Actual_Result);
            if Actual_Result /= Intended_Result2 then
                return Fail;
            end if;
            My_Scan (Test_Str3, Test_Context, Actual_Result);
            if Actual_Result /= Intended_Result3 then
                return Fail;
            end if;
            return Pass;
        end Scan_Set_Check;


        function Scan_Set_With_Check
            return Test_Result
        is
            Sentinel : Natural := 2;
            function More_Input
                return String is
            begin
                if Sentinel > 1 then
                    Sentinel := 1;
                    return "it will happen again";
                elsif Sentinel > 0 then
                    Sentinel := 0;
                    return " and again and again";
                else
                    return "";
                end if;
            end More_Input;

            procedure My_Scan is new Swordy.Scan_Set_With
               ((Stamp_Word'Access, Ignore_Whitespace'Access),
                Latin.EOT, Word_Tokens.Create (Blank, 1, 0, ""));

            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Intended_Result1 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 1, 2, "it"),
                2 => Word_Tokens.Create (Word, 4, 7, "will"),
                3 => Word_Tokens.Create (Word, 9, 14, "happen"),
                4 => Word_Tokens.Create (Word, 16, 20, "again"),
                5 => Word_Tokens.Create (Word, 22, 24, "and"));
            Intended_Result2 : Word_Tokens.Token_Array :=
               (1 => Word_Tokens.Create (Word, 26, 30, "again"),
                2 => Word_Tokens.Create (Word, 32, 34, "and"),
                3 => Word_Tokens.Create (Word, 36, 40, "again"),
                4 => Word_Tokens.Create (Blank, 1, 0, ""),
                5 => Word_Tokens.Create (Blank, 1, 0, ""));

            Actual_Result : Word_Tokens.Token_Array (1 .. 5);
        begin
            My_Scan (More_Input'Unrestricted_Access, Test_Context, Actual_Result);
            if Actual_Result /= Intended_Result1 then
                return Fail;
            end if;
            My_Scan (More_Input'Unrestricted_Access, Test_Context, Actual_Result);
            if Actual_Result /= Intended_Result2 then
                return Fail;
            end if;
            return Pass;
        end Scan_Set_With_Check;


        function Scan_Error_Check
            return Test_Result
        is
            use type Packrat.Errors.Error_Info_Array;

            function My_Scan is new Swordy.Scan
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Str : String := "()()";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Expected_Errors : Packrat.Errors.Error_Info_Array :=
                ((+"WORD", 1), (+"WHITESPACE", 1));
        begin
            declare
                Result : Word_Tokens.Token_Array := My_Scan (Test_Str, Test_Context);
            begin
                return Fail;
            end;
        exception
            when Msg : Packrat.Lexer_Error =>
                if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then
                    return Fail;
                end if;
                return Pass;
        end Scan_Error_Check;


        function Scan_Only_Error_Check
            return Test_Result
        is
            use type Packrat.Errors.Error_Info_Array;

            function My_Scan is new Swordy.Scan_Only
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Str : String := "()()";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Expected_Errors : Packrat.Errors.Error_Info_Array :=
                ((+"WORD", 1), (+"WHITESPACE", 1));
        begin
            declare
                Result : Word_Tokens.Token_Array := My_Scan (Test_Str, Test_Context);
            begin
                return Fail;
            end;
        exception
            when Msg : Packrat.Lexer_Error =>
                if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then
                    return Fail;
                end if;
                return Pass;
        end Scan_Only_Error_Check;


        function Scan_With_Error_Check
            return Test_Result
        is
            use type Packrat.Errors.Error_Info_Array;

            Sentinel : Integer := 1;
            function Get_Input
                return String is
            begin
                if Sentinel > 0 then
                    Sentinel := 0;
                    return "()()";
                else
                    return "";
                end if;
            end Get_Input;

            function My_Scan is new Swordy.Scan_With
                ((Stamp_Word'Access, Ignore_Whitespace'Access));

            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Expected_Errors : Packrat.Errors.Error_Info_Array :=
                ((+"WORD", 1), (+"WHITESPACE", 1));
        begin
            declare
                Result : Word_Tokens.Token_Array :=
                    My_Scan (Get_Input'Unrestricted_Access, Test_Context);
            begin
                return Fail;
            end;
        exception
            when Msg : Packrat.Lexer_Error =>
                if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then
                    return Fail;
                end if;
                return Pass;
        end Scan_With_Error_Check;


        function Scan_Set_Error_Check
            return Test_Result
        is
            use type Packrat.Errors.Error_Info_Array;

            procedure My_Scan is new Swordy.Scan_Set
               ((Stamp_Word'Access, Ignore_Whitespace'Access),
                Latin.EOT, Word_Tokens.Create (Blank, 1, 0, ""));

            Test_Str : String := "()()";
            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Result : Word_Tokens.Token_Array (1 .. 5);

            Expected_Errors : Packrat.Errors.Error_Info_Array :=
                ((+"WORD", 1), (+"WHITESPACE", 1));
        begin
            My_Scan (Test_Str, Test_Context, Result);
            return Fail;
        exception
            when Msg : Packrat.Lexer_Error =>
                if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then
                    return Fail;
                end if;
                return Pass;
        end Scan_Set_Error_Check;


        function Scan_Set_With_Error_Check
            return Test_Result
        is
            use type Packrat.Errors.Error_Info_Array;

            Sentinel : Integer := 1;
            function Get_Input
                return String is
            begin
                if Sentinel > 0 then
                    Sentinel := 0;
                    return "()()";
                else
                    return "";
                end if;
            end Get_Input;

            procedure My_Scan is new Swordy.Scan_Set_With
               ((Stamp_Word'Access, Ignore_Whitespace'Access),
                Latin.EOT, Word_Tokens.Create (Blank, 1, 0, ""));

            Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;

            Result : Word_Tokens.Token_Array (1 .. 5);

            Expected_Errors : Packrat.Errors.Error_Info_Array :=
                ((+"WORD", 1), (+"WHITESPACE", 1));
        begin
            My_Scan (Get_Input'Unrestricted_Access, Test_Context, Result);
            return Fail;
        exception
            when Msg : Packrat.Lexer_Error =>
                if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then
                    return Fail;
                end if;
                return Pass;
        end Scan_Set_With_Error_Check;


    end Lexer;





    package body Graphs is


        type My_Labels is (One, Two, Three, Four, Five, Six);

        package My_Interfaces is new Packrat.Interfaces (My_Labels, Character, String);
        package My_Graphs is new Packrat.Graphs (My_Labels, Character, String, My_Interfaces);


        use type My_Interfaces.Cursor;
        use type My_Graphs.Parse_Graph;


        function Node_Check
            return Test_Result
        is
            Leafeon   : My_Graphs.Node := My_Graphs.Leaf ("abc", 1, 3);
            Brancheon : My_Graphs.Node := My_Graphs.Branch (One, 4, 3);
        begin
            if  Leafeon.Elements /= "abc" or Brancheon.Label /= One or
                Leafeon.Start /= 1 or Brancheon.Start /= 4 or
                Leafeon.Finish /= 3 or Brancheon.Finish /= 3
            then
                return Fail;
            end if;
            return Pass;
        end Node_Check;


        function Cursor_Check
            return Test_Result is
        begin
            return Fail;
        end Cursor_Check;


        function Empty_Check
            return Test_Result is
        begin
            if not My_Graphs.Empty_Graph.Is_Empty or not My_Graphs.No_Position.Is_Nothing then
                return Fail;
            end if;
            return Pass;
        end Empty_Check;


        function Attachment_Check
            return Test_Result is
        begin
            return Fail;
        end Attachment_Check;


        function Find_Check
            return Test_Result
        is
            Leafeon   : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("abc", 1, 3));
            Brancheon : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Branch (One, 1, 5));
            Combined  : My_Graphs.Parse_Graph := Brancheon;
        begin
            Combined.Attach_Choice (Combined.Root (1), Leafeon);
            declare
                Expected_Result : My_Interfaces.Cursor'Class := Combined.Root (1).First_Child;
            begin
                if  Combined.Find ("abc") /= Expected_Result or
                    Combined.Find ("def") /= My_Graphs.No_Position or
                    Brancheon.Find ("any") /= My_Graphs.No_Position
                then
                    return Fail;
                end if;
            end;
            return Pass;
        end Find_Check;


    end Graphs;





    package body Util is


        function In_Set_Check
            return Test_Result
        is
            use type Strmaps.Character_Set;
            Set_1 : Strmaps.Character_Set := Strmaps.To_Set ("abcxyz");
            Set_2 : Strmaps.Character_Set := Strmaps.To_Set ("!""#$");
            function Func_1 is new PU.In_Set (Set_1);
            function Func_2 is new PU.In_Set (Set_2);
        begin
            --  Func_1 testing
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('a') - 1 loop
                if Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'a' .. 'c' loop
                if not Func_1 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('c') + 1 .. Character'Pos ('x') - 1 loop
                if Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'x' .. 'z' loop
                if not Func_1 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('z') + 1 .. Character'Pos (Character'Last) loop
                if Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            --  Func_2 testing
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('!') - 1 loop
                if Func_2 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '!' .. '$' loop
                if not Func_2 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('$') + 1 .. Character'Pos (Character'Last) loop
                if Func_2 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end In_Set_Check;


        function Not_In_Set_Check
            return Test_Result
        is
            use type Strmaps.Character_Set;
            Set_1 : Strmaps.Character_Set := Strmaps.To_Set ("abcxyz");
            Set_2 : Strmaps.Character_Set := Strmaps.To_Set ("!""#$");
            function Func_1 is new PU.Not_In_Set (Set_1);
            function Func_2 is new PU.Not_In_Set (Set_2);
        begin
            --  Func_1 testing
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('a') - 1 loop
                if not Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'a' .. 'c' loop
                if Func_1 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('c') + 1 .. Character'Pos ('x') - 1 loop
                if not Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'x' .. 'z' loop
                if Func_1 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('z') + 1 .. Character'Pos (Character'Last) loop
                if not Func_1 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            --  Func_2 testing
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('!') - 1 loop
                if not Func_2 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '!' .. '$' loop
                if Func_2 (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('$') + 1 .. Character'Pos (Character'Last) loop
                if not Func_2 (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Not_In_Set_Check;





        function Is_Digit_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('0') - 1 loop
                if PU.Is_Digit (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '0' .. '9' loop
                if not PU.Is_Digit (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('9') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Digit (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Digit_Check;


        function Is_Hex_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('0') - 1 loop
                if PU.Is_Hex (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '0' .. '9' loop
                if not PU.Is_Hex (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('9') + 1 .. Character'Pos ('A') - 1 loop
                if PU.Is_Hex (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'A' .. 'F' loop
                if not PU.Is_Hex (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('F') + 1 .. Character'Pos ('a') - 1 loop
                if PU.Is_Hex (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'a' .. 'f' loop
                if not PU.Is_Hex (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('f') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Hex (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Hex_Check;


        function Is_Letter_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('A') - 1 loop
                if PU.Is_Letter (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'A' .. 'Z' loop
                if not PU.Is_Letter (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('Z') + 1 .. Character'Pos ('a') - 1 loop
                if PU.Is_Letter (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'a' .. 'z' loop
                if not PU.Is_Letter (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('z') + 1 .. Character'Pos (Character'First) loop
                if PU.Is_Letter (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Letter_Check;


        function Is_Alphanumeric_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('0') - 1 loop
                if PU.Is_Alphanumeric (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '0' .. '9' loop
                if not PU.Is_Alphanumeric (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('9') + 1 .. Character'Pos ('A') - 1 loop
                if PU.Is_Alphanumeric (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'A' .. 'Z' loop
                if not PU.Is_Alphanumeric (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('Z') + 1 .. Character'Pos ('a') - 1 loop
                if PU.Is_Alphanumeric (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range 'a' .. 'z' loop
                if not PU.Is_Alphanumeric (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('z') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Alphanumeric (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Alphanumeric_Check;


        function Is_Punctuation_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos ('!') - 1 loop
                if PU.Is_Punctuation (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '!' .. '/' loop
                if not PU.Is_Punctuation (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('/') + 1 .. Character'Pos (':') - 1 loop
                if PU.Is_Punctuation (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range ':' .. '@' loop
                if not PU.Is_Punctuation (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('@') + 1 .. Character'Pos ('[') - 1 loop
                if PU.Is_Punctuation (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '[' .. '`' loop
                if not PU.Is_Punctuation (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('`') + 1 .. Character'Pos ('{') - 1 loop
                if PU.Is_Punctuation (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range '{' .. '~' loop
                if not PU.Is_Punctuation (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos ('~') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Punctuation (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Punctuation_Check;


        function Is_ASCII_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. 127 loop
                if not PU.Is_ASCII (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range 128 .. Character'Pos (Character'Last) loop
                if PU.Is_ASCII (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_ASCII_Check;


        function Is_Extended_ASCII_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. 127 loop
                if PU.Is_Extended_ASCII (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range 128 .. Character'Pos (Character'Last) loop
                if not PU.Is_Extended_ASCII (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Extended_ASCII_Check;


        function Is_Space_Check
            return Test_Result is
        begin
            for I in Integer range Character'Pos (Character'First) .. Character'Pos (' ') - 1 loop
                if PU.Is_Space (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_Space (' ') then
                return Fail;
            end if;
            for I in Integer range Character'Pos (' ') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Space (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Space_Check;


        function Is_Linespace_Check
            return Test_Result is
        begin
            for I in Integer range
                Character'Pos (Character'First) .. Character'Pos (Latin.HT) - 1
            loop
                if PU.Is_Linespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_Linespace (Latin.HT) then
                return Fail;
            end if;
            for I in Integer range Character'Pos (Latin.HT) + 1 .. Character'Pos (' ') - 1 loop
                if PU.Is_Linespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_Linespace (' ') then
                return Fail;
            end if;
            for I in Integer range Character'Pos (' ') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Linespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Linespace_Check;


        function Is_End_Of_Line_Check
            return Test_Result is
        begin
            for I in Integer range
                Character'Pos (Character'First) .. Character'Pos (Latin.LF) - 1
            loop
                if PU.Is_End_Of_Line (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_End_Of_Line (Latin.LF) then
                return Fail;
            end if;
            for I in Integer range Character'Pos (Latin.LF) + 1 .. Character'Pos (Latin.CR) - 1 loop
                if PU.Is_End_Of_Line (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_End_Of_Line (Latin.CR) then
                return Fail;
            end if;
            for I in Integer range
                Character'Pos (Latin.CR) + 1 .. Character'Pos (Character'Last)
            loop
                if PU.Is_End_Of_Line (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_End_Of_Line_Check;


        function Is_Whitespace_Check
            return Test_Result is
        begin
            for I in Integer range
                Character'Pos (Character'First) .. Character'Pos (Latin.HT) - 1
            loop
                if PU.Is_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range Latin.HT .. Latin.LF loop
                if not PU.Is_Whitespace (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos (Latin.LF) + 1 .. Character'Pos (Latin.CR) - 1 loop
                if PU.Is_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_Whitespace (Latin.CR) then
                return Fail;
            end if;
            for I in Integer range Character'Pos (Latin.CR) + 1 .. Character'Pos (' ') - 1 loop
                if PU.Is_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if not PU.Is_Whitespace (' ') then
                return Fail;
            end if;
            for I in Integer range Character'Pos (' ') + 1 .. Character'Pos (Character'Last) loop
                if PU.Is_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Is_Whitespace_Check;


        function Not_Whitespace_Check
            return Test_Result is
        begin
            for I in Integer range
                Character'Pos (Character'First) .. Character'Pos (Latin.HT) - 1
            loop
                if not PU.Not_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            for C in Character range Latin.HT .. Latin.LF loop
                if PU.Not_Whitespace (C) then
                    return Fail;
                end if;
            end loop;
            for I in Integer range Character'Pos (Latin.LF) + 1 .. Character'Pos (Latin.CR) - 1 loop
                if not PU.Not_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if PU.Not_Whitespace (Latin.CR) then
                return Fail;
            end if;
            for I in Integer range Character'Pos (Latin.CR) + 1 .. Character'Pos (' ') - 1 loop
                if not PU.Not_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            if PU.Not_Whitespace (' ') then
                return Fail;
            end if;
            for I in Integer range Character'Pos (' ') + 1 .. Character'Pos (Character'Last) loop
                if not PU.Not_Whitespace (Character'Val (I)) then
                    return Fail;
                end if;
            end loop;
            return Pass;
        end Not_Whitespace_Check;


    end Util;


end Ratnest.Tests;