Cleaned up Lexer, Util package names

1 files changed, 1022 insertions, 0 deletions

diff --git a/test/rat_tests-lexers.adb b/test/rat_tests-lexers.adb
new file mode 100644
index 0000000..0087f60
--- /dev/null
+++ b/test/rat_tests-lexers.adb
@@ -0,0 +1,1022 @@
+
+
+with
+
+    Packrat.Errors,
+    Packrat.Traits,
+    Packrat.Lexers.Debug,
+    Packrat.Utilities;
+
+
+package body Rat_Tests.Lexers is
+
+
+    package PU renames Packrat.Utilities;
+
+
+    type My_Labels is (One, Two, Three);
+
+
+    package Slexy_Traits is new Packrat.Traits (My_Labels, Character, String);
+    package Slexy is new Packrat.Lexers (Slexy_Traits);
+    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 Slexy_Traits.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) /= Slexy_Traits.Tokens.Create (One, 1, "abc")) or
+            Slebug.Position (Context1) /= 4 or Slebug.Status (Context1) /= Packrat.Success or
+            Slebug.Has_Pass (Context1)
+        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) /= Slexy_Traits.Tokens.Create (One, 1, "abc")) or
+            Slebug.Position (Context1) /= 4 or not Slebug.Is_Failure (Comp_Code) or
+            Slebug.Has_Pass (Context1)
+        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
+           (not Slebug.Has_Pass (Context2) or else Slebug.Pass (Context2) /= "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.Has_Pass (Context1)
+        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.Has_Pass (Context1)
+        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
+           (not Slebug.Has_Pass (Context2) or else Slebug.Pass (Context2) /= "ab")
+        then
+            return Fail;
+        end if;
+        return Pass;
+    end Ignore_Check;
+
+
+
+
+
+    type Word_Enum is (Blank, Word, Whitespace);
+
+    package Swordy_Traits is new Packrat.Traits (Word_Enum, Character, String);
+    package Swordy is new Packrat.Lexers (Swordy_Traits);
+    package Swolbug is new Swordy.Debug;
+
+    use type Swordy_Traits.Tokens.Token;
+    use type Swordy_Traits.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 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"),
+            2 => Swordy_Traits.Tokens.Create (Word, 5, "fine"));
+        Intended_Result2 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 10, "day"));
+
+        Actual_Result1 : Swordy_Traits.Tokens.Token_Array :=
+            My_Scan (Test_Str, Test_Context);
+        Actual_Result2 : Swordy_Traits.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 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"),
+            2 => Swordy_Traits.Tokens.Create (Word, 5, "fine"),
+            3 => Swordy_Traits.Tokens.Create (Word, 10, "day"));
+
+        Actual_Result : Swordy_Traits.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 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 1, "it"),
+            2 => Swordy_Traits.Tokens.Create (Word, 4, "will"),
+            3 => Swordy_Traits.Tokens.Create (Word, 9, "happen"),
+            4 => Swordy_Traits.Tokens.Create (Word, 17, "again"),
+            5 => Swordy_Traits.Tokens.Create (Word, 23, "and"),
+            6 => Swordy_Traits.Tokens.Create (Word, 27, "again"),
+            7 => Swordy_Traits.Tokens.Create (Word, 33, "and"),
+            8 => Swordy_Traits.Tokens.Create (Word, 37, "again"));
+
+        Actual_Result : Swordy_Traits.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, Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        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 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"),
+            2 => Swordy_Traits.Tokens.Create (Blank, 1, ""),
+            3 => Swordy_Traits.Tokens.Create (Blank, 1, ""));
+        Intended_Result2 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 9, "two"),
+            2 => Swordy_Traits.Tokens.Create (Blank, 1, ""),
+            3 => Swordy_Traits.Tokens.Create (Blank, 1, ""));
+        Intended_Result3 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 16, "three"),
+            2 => Swordy_Traits.Tokens.Create (Blank, 1, ""),
+            3 => Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        Actual_Result : Swordy_Traits.Tokens.Token_Array (1 .. 3);
+    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, Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;
+
+        Intended_Result1 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 1, "it"),
+            2 => Swordy_Traits.Tokens.Create (Word, 4, "will"),
+            3 => Swordy_Traits.Tokens.Create (Word, 9, "happen"),
+            4 => Swordy_Traits.Tokens.Create (Word, 16, "again"),
+            5 => Swordy_Traits.Tokens.Create (Word, 22, "and"));
+        Intended_Result2 : Swordy_Traits.Tokens.Token_Array :=
+           (1 => Swordy_Traits.Tokens.Create (Word, 26, "again"),
+            2 => Swordy_Traits.Tokens.Create (Word, 32, "and"),
+            3 => Swordy_Traits.Tokens.Create (Word, 36, "again"),
+            4 => Swordy_Traits.Tokens.Create (Blank, 1, ""),
+            5 => Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        Actual_Result : Swordy_Traits.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 : Swordy_Traits.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 : Swordy_Traits.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 : Swordy_Traits.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, Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        Test_Str : String := "()()";
+        Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;
+
+        Result : Swordy_Traits.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, Swordy_Traits.Tokens.Create (Blank, 1, ""));
+
+        Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context;
+
+        Result : Swordy_Traits.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 Rat_Tests.Lexers;
+
+