Completed more Graphs tests, restructured Ratnest.Tests package layout

7 files changed, 1887 insertions, 1808 deletions

diff --git a/test/ratnest-tests-errors.adb b/test/ratnest-tests-errors.adb
new file mode 100644
index 0000000..136f6c9
--- /dev/null
+++ b/test/ratnest-tests-errors.adb
@@ -0,0 +1,161 @@
+
+
+separate (Ratnest.Tests)
+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;
+
+
diff --git a/test/ratnest-tests-graphs.adb b/test/ratnest-tests-graphs.adb
new file mode 100644
index 0000000..8776336
--- /dev/null
+++ b/test/ratnest-tests-graphs.adb
@@ -0,0 +1,132 @@
+
+
+separate (Ratnest.Tests)
+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 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
+        Leaf1 : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("abc", 1, 3));
+        Leaf2 : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("def", 4, 6));
+        Leaf3 : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("abc", 4, 6));
+        Leaf4 : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("def", 1, 3));
+
+        Brancheon : My_Graphs.Parse_Graph :=
+            My_Graphs.Singleton (My_Graphs.Branch (Three, 1, 15));
+
+        Merge1 : My_Graphs.Parse_Graph := Leaf1;
+        Merge2 : My_Graphs.Parse_Graph := Leaf3;
+        Merge3 : My_Graphs.Parse_Graph := Brancheon;
+
+        Cursor1 : My_Interfaces.Cursor'Class := Merge3.Root (1);
+    begin
+        Merge1.Append (Leaf2);
+        Merge2.Prepend (Leaf4);
+        Merge3.Attach_Choice (Cursor1, Merge1);
+
+        if  Merge1.Root_Count /= 2 or else
+            Merge2.Root_Count /= 2 or else
+            Merge3.Root_Count /= 1 or else
+            not Merge1.Root (1).Is_Leaf or else not Merge1.Root (2).Is_Leaf or else
+            Merge1.Root (1).Elements /= "abc" or else Merge1.Root (2).Elements /= "def" or else
+            not Merge2.Root (1).Is_Leaf or else not Merge2.Root (2).Is_Leaf or else
+            Merge2.Root (1).Elements /= "def" or else Merge2.Root (2).Elements /= "abc" or else
+            not Merge3.Root (1).Is_Branch or else
+            Cursor1.Label /= Three or else Cursor1.Child_Count /= 2 or else
+            Cursor1.First_Child.Elements /= "abc" or else Cursor1.Last_Child.Elements /= "def"
+        then
+            return Fail;
+        end if;
+        return Pass;
+    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;
+
+
+    function Find_Subgraph_Check
+        return Test_Result
+    is
+        Leafeon  : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Leaf ("abc", 1, 3));
+        Branch1  : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Branch (One, 1, 4));
+        Branch2  : My_Graphs.Parse_Graph := My_Graphs.Singleton (My_Graphs.Branch (Two, 1, 5));
+        Combined : My_Graphs.Parse_Graph := Branch2;
+
+        My_Cursor : My_Interfaces.Cursor'Class := Combined.Root (1);
+    begin
+        Combined.Attach_Choice (My_Cursor, Branch1);
+        My_Cursor := My_Cursor.First_Child;
+        Combined.Attach_Choice (My_Cursor, Leafeon);
+
+        declare
+            Expected_Result : My_Interfaces.Cursor'Class := My_Cursor.First_Child;
+        begin
+            if  My_Cursor.Find_In_Subgraph ("abc") /= Expected_Result or
+                My_Cursor.Find_In_Subgraph ("def") /= My_Graphs.No_Position
+            then
+                return Fail;
+            end if;
+        end;
+        return Pass;
+    end Find_Subgraph_Check;
+
+
+end Graphs;
+
+
diff --git a/test/ratnest-tests-lexer.adb b/test/ratnest-tests-lexer.adb
new file mode 100644
index 0000000..9728829
--- /dev/null
+++ b/test/ratnest-tests-lexer.adb
@@ -0,0 +1,1009 @@
+
+
+separate (Ratnest.Tests)
+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;
+
+
diff --git a/test/ratnest-tests-tokens.adb b/test/ratnest-tests-tokens.adb
new file mode 100644
index 0000000..7a2588a
--- /dev/null
+++ b/test/ratnest-tests-tokens.adb
@@ -0,0 +1,69 @@
+
+
+separate (Ratnest.Tests)
+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;
+
+
diff --git a/test/ratnest-tests-util.adb b/test/ratnest-tests-util.adb
new file mode 100644
index 0000000..ca5f235
--- /dev/null
+++ b/test/ratnest-tests-util.adb
@@ -0,0 +1,508 @@
+
+
+separate (Ratnest.Tests)
+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;
+
+
diff --git a/test/ratnest-tests.adb b/test/ratnest-tests.adb
index 5153b9f..dfc8dec 100644
--- a/test/ratnest-tests.adb
+++ b/test/ratnest-tests.adb
@@ -20,1811 +20,11 @@ package body Ratnest.Tests is
     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;
+    package body Errors is separate;
+    package body Tokens is separate;
+    package body Lexer is separate;
+    package body Graphs is separate;
+    package body Util is separate;
 
 
 end Ratnest.Tests;
diff --git a/test/ratnest-tests.ads b/test/ratnest-tests.ads
index b8efd8d..bd0b4fe 100644
--- a/test/ratnest-tests.ads
+++ b/test/ratnest-tests.ads
@@ -123,18 +123,18 @@ package Ratnest.Tests is
     package Graphs is
 
         function Node_Check return Test_Result;
-        function Cursor_Check return Test_Result;
 
         function Empty_Check return Test_Result;
         function Attachment_Check return Test_Result;
         function Find_Check return Test_Result;
+        function Find_Subgraph_Check return Test_Result;
 
         Graph_Tests : Test_Array :=
            ((+"Node", Node_Check'Access),
-            (+"Cursor", Cursor_Check'Access),
             (+"Emptiness", Empty_Check'Access),
             (+"Attachment", Attachment_Check'Access),
-            (+"Find", Find_Check'Access));
+            (+"Find", Find_Check'Access),
+            (+"Find_Subgraph", Find_Subgraph_Check'Access));
 
     end Graphs;