From 81c4526fa275a256bfefe0f8a7cd638369ea1252 Mon Sep 17 00:00:00 2001 From: Jed Barber Date: Sat, 28 Nov 2020 16:24:04 +1100 Subject: Cleaned up Lexer, Util package names --- test/rat_tests-lexers.adb | 1022 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1022 insertions(+) create mode 100644 test/rat_tests-lexers.adb (limited to 'test/rat_tests-lexers.adb') diff --git a/test/rat_tests-lexers.adb b/test/rat_tests-lexers.adb new file mode 100644 index 0000000..0087f60 --- /dev/null +++ b/test/rat_tests-lexers.adb @@ -0,0 +1,1022 @@ + + +with + + Packrat.Errors, + Packrat.Traits, + Packrat.Lexers.Debug, + Packrat.Utilities; + + +package body Rat_Tests.Lexers is + + + package PU renames Packrat.Utilities; + + + type My_Labels is (One, Two, Three); + + + package Slexy_Traits is new Packrat.Traits (My_Labels, Character, String); + package Slexy is new Packrat.Lexers (Slexy_Traits); + package Slebug is new Slexy.Debug; + + + use type Slexy.Combinator_Result; + + + + + + function Join_Check + return Test_Result + is + One : Slexy.Combinator_Result := + Slebug.Create_Result (1, Packrat.Success); + Two : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Three : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + + Four : Slexy.Combinator_Result := + Slebug.Create_Result (4, Packrat.Failure); + Five : Slexy.Combinator_Result := + Slebug.Create_Result (4, Packrat.Failure); + + Six : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Needs_More); + Seven : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Needs_More); + + Eight : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Failure); + + Nine : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Optional_More); + Ten : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Eleven : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + begin + if Slebug.Join (One, Two) /= Three or Slebug.Join (One, Four) /= Five or + Slebug.Join (One, Six) /= Seven or Slebug.Join (Four, Six) /= Four or + Slebug.Join (Five, Two) /= Five or Slebug.Join (Six, Three) /= Eight or + Slebug.Join (Slebug.Empty_Fail, One) /= Slebug.Empty_Fail or + Slebug.Join (Nine, Ten) /= Eleven + then + return Fail; + end if; + return Pass; + end Join_Check; + + + function Equals_Check + return Test_Result + is + One : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Two : Slexy.Combinator_Result := + Slebug.Create_Result (0, Packrat.Failure); + begin + if One = Two or Two /= Slebug.Empty_Fail then + return Fail; + end if; + return Pass; + end Equals_Check; + + + + + + function Sequence_Check + return Test_Result + is + function Match_A is new Slexy.Match ('a'); + function Match_B is new Slexy.Match ('b'); + function Match_C is new Slexy.Match ('c'); + function Seq_Abc is new Slexy.Sequence + ((Match_A'Unrestricted_Access, + Match_B'Unrestricted_Access, + Match_C'Unrestricted_Access)); + + Test_Str : String := "aababcabcab"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (1, Packrat.Failure); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (11, Packrat.Needs_More); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (6, Packrat.Success); + Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail; + Result5 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Failure); + begin + if Seq_Abc (Test_Str, 1) /= Result1 or Seq_Abc (Test_Str, 2) /= Result5 or + Seq_Abc (Test_Str, 4) /= Result3 or Seq_Abc (Test_Str, 10) /= Result2 or + Seq_Abc (Test_Str, 3) /= Result4 or + Seq_Abc (Test_Str, Test_Str'Last + 5) /= Result4 + then + return Fail; + end if; + return Pass; + end Sequence_Check; + + + function Count_Check + return Test_Result + is + function Match_A is new Slexy.Match ('a'); + function Match_B is new Slexy.Match ('b'); + function Count_2A is new Slexy.Count (Match_A, 2); + function Count_3B is new Slexy.Count (Match_B, 3); + + Test_Str : String := "abaabbaaabbbaaaabbbb"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (1, Packrat.Failure); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (4, Packrat.Success); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (2, Packrat.Failure); + Result4 : Slexy.Combinator_Result := + Slebug.Create_Result (20, Packrat.Needs_More); + Result5 : Slexy.Combinator_Result := + Slebug.Create_Result (12, Packrat.Success); + Result6 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Count_2A (Test_Str, 1) /= Result1 or Count_2A (Test_Str, 3) /= Result2 or + Count_3B (Test_Str, 2) /= Result3 or Count_3B (Test_Str, 19) /= Result4 or + Count_3B (Test_Str, 10) /= Result5 or Count_3B (Test_Str, 1) /= Result6 or + Count_2A (Test_Str, 2) /= Result6 or + Count_2A (Test_Str, Test_Str'Last + 5) /= Result6 + then + return Fail; + end if; + return Pass; + end Count_Check; + + + function Many_Check + return Test_Result + is + function Match_A is new Slexy.Match ('a'); + function Many_0 is new Slexy.Many (Match_A); + function Many_4 is new Slexy.Many (Match_A, 4); + + function Match_B is new Slexy.Match ('b'); + function Match_C is new Slexy.Match ('c'); + function Seq_Abc is new Slexy.Sequence + ((Match_A'Unrestricted_Access, + Match_B'Unrestricted_Access, + Match_C'Unrestricted_Access)); + function Many_Seq_0 is new Slexy.Many (Seq_Abc); + function Many_Seq_4 is new Slexy.Many (Seq_Abc, 4); + + Test_Str : String := "aaabbaaaaabaa"; + Test_Str2 : String := "aababcabcab"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (13, Packrat.Optional_More); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (10, Packrat.Success); + Result4 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Failure); + Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail; + Result6 : Slexy.Combinator_Result := + Slebug.Create_Result (13, Packrat.Needs_More); + Result7 : Slexy.Combinator_Result := + Slebug.Create_Result (0, Packrat.Success); + Result8 : Slexy.Combinator_Result := + Slebug.Create_Result (9, Packrat.Optional_More); + Result9 : Slexy.Combinator_Result := + Slebug.Create_Result (9, Packrat.Needs_More); + begin + if Many_0 (Test_Str, 1) /= Result1 or Many_4 (Test_Str, 1) /= Result4 or + Many_4 (Test_Str, 6) /= Result3 or Many_0 (Test_Str, 4) /= Result7 or + Many_0 (Test_Str, 12) /= Result2 or Many_4 (Test_Str, 12) /= Result6 or + Many_0 (Test_Str, Test_Str'Last + 5) /= Result5 or + Many_Seq_0 (Test_Str2, 4) /= Result8 or Many_Seq_4 (Test_Str2, 4) /= Result9 + then + return Fail; + end if; + return Pass; + end Many_Check; + + + function Many_Until_Check + return Test_Result + is + function Match_A is new Slexy.Match ('a'); + function Many_Until_0 is new Slexy.Many_Until (Match_A, PU.Is_Digit); + function Many_Until_3 is new Slexy.Many_Until (Match_A, PU.Is_Digit, 3); + + Test_Str : String := "aaaabbaaa123aaa"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (4, Packrat.Failure); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (9, Packrat.Success); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (15, Packrat.Needs_More); + Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Many_Until_0 (Test_Str, 1) /= Result1 or + Many_Until_0 (Test_Str, 7) /= Result2 or + Many_Until_3 (Test_Str, 7) /= Result2 or + Many_Until_3 (Test_Str, 13) /= Result3 or + Many_Until_0 (Test_Str, 5) /= Result4 or + Many_Until_0 (Test_Str, Test_Str'Last + 5) /= Result4 or + Many_Until_3 (Test_Str, Test_Str'Last + 5) /= Result4 + then + return Fail; + end if; + return Pass; + end Many_Until_Check; + + + function Satisfy_Check + return Test_Result + is + function Is_123 + (Char : in Character) + return Boolean is + begin + return Char = '1' or Char = '2' or Char = '3'; + end Is_123; + function Is_Abc + (Char : in Character) + return Boolean is + begin + return Char = 'a' or Char = 'b' or Char = 'c'; + end Is_Abc; + + function Satisfy_123 is new Slexy.Satisfy (Is_123); + function Satisfy_Abc is new Slexy.Satisfy (Is_Abc); + + Test_Str : String := "abc123456def"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (2, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (6, Packrat.Success); + Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Satisfy_123 (Test_Str, 6) /= Result2 or + Satisfy_Abc (Test_Str, 2) /= Result1 or + Satisfy_Abc (Test_Str, 8) /= Result3 or + Satisfy_123 (Test_Str, Test_Str'Last + 5) /= Result3 + then + return Fail; + end if; + return Pass; + end Satisfy_Check; + + + function Satisfy_With_Check + return Test_Result + is + function Is_Abc + (Char : in Character) + return Boolean is + begin + return Char = 'a' or Char = 'b' or Char = 'c'; + end Is_Abc; + function Is_123 + (Char : in Character) + return Boolean is + begin + return Char = '1' or Char = '2' or Char = '3'; + end Is_123; + function Minus_One + (Char : in Character) + return Character is + begin + return Character'Val (Character'Pos (Char) - 1); + end Minus_One; + + function Satisfy_Bcd is new Slexy.Satisfy_With (Is_Abc, Minus_One); + function Satisfy_234 is new Slexy.Satisfy_With (Is_123, Minus_One); + + Test_Str : String := "abcde12345"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (7, Packrat.Success); + Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Satisfy_Bcd (Test_Str, 3) /= Result1 or + Satisfy_234 (Test_Str, 7) /= Result2 or + Satisfy_Bcd (Test_Str, 1) /= Result3 or + Satisfy_234 (Test_Str, Test_Str'Last + 5) /= Result3 + then + return Fail; + end if; + return Pass; + end Satisfy_With_Check; + + + function Match_Check + return Test_Result + is + function Match_A is new Slexy.Match ('a'); + function Match_Slash is new Slexy.Match ('/'); + function Match_4 is new Slexy.Match ('4'); + + Test_Str : String := "abc1234./5"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (1, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (9, Packrat.Success); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (7, Packrat.Success); + Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Match_A (Test_Str, 1) /= Result1 or + Match_Slash (Test_Str, 9) /= Result2 or + Match_4 (Test_Str, 7) /= Result3 or + Match_A (Test_Str, 3) /= Result4 or + Match_A (Test_Str, Test_Str'Last + 5) /= Result4 + then + return Fail; + end if; + return Pass; + end Match_Check; + + + function Match_With_Check + return Test_Result + is + function Plus_One + (Char : in Character) + return Character is + begin + return Character'Val (Character'Pos (Char) + 1); + end Plus_One; + + function Match_A is new Slexy.Match_With ('b', Plus_One); + function Match_6 is new Slexy.Match_With ('7', Plus_One); + + Test_Str : String := "abc5678"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (1, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Match_A (Test_Str, 1) /= Result1 or + Match_6 (Test_Str, 5) /= Result2 or + Match_A (Test_Str, 2) /= Result3 or + Match_A (Test_Str, Test_Str'Last + 5) /= Result3 + then + return Fail; + end if; + return Pass; + end Match_With_Check; + + + function Multimatch_Check + return Test_Result + is + function Match_String1 is new Slexy.Multimatch ("abc"); + function Match_String2 is new Slexy.Multimatch ("hello"); + + Test_Str : String := "abcdefabhelloworldab"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (20, Packrat.Needs_More); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (13, Packrat.Success); + Result4 : Slexy.Combinator_Result := + Slebug.Create_Result (8, Packrat.Failure); + Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Match_String1 (Test_Str, 1) /= Result1 or + Match_String1 (Test_Str, 7) /= Result4 or + Match_String2 (Test_Str, 9) /= Result3 or + Match_String2 (Test_Str, 3) /= Result5 or + Match_String1 (Test_Str, 19) /= Result2 or + Match_String1 (Test_Str, Test_Str'Last + 5) /= Result5 + then + return Fail; + end if; + return Pass; + end Multimatch_Check; + + + function Take_Check + return Test_Result + is + function Take_1 is new Slexy.Take; + function Take_5 is new Slexy.Take (5); + + Test_Str : String := "abcdefghi"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (2, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (9, Packrat.Needs_More); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (7, Packrat.Success); + Result4 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Take_1 (Test_Str, 2) /= Result1 or Take_5 (Test_Str, 7) /= Result2 or + Take_5 (Test_Str, 3) /= Result3 or + Take_1 (Test_Str, Test_Str'Last + 5) /= Result4 + then + return Fail; + end if; + return Pass; + end Take_Check; + + + function Take_While_Check + return Test_Result + is + function Take_Letters is new Slexy.Take_While (PU.Is_Letter); + function Take_Punch is new Slexy.Take_While (PU.Is_Punctuation); + function Take_Digits is new Slexy.Take_While (PU.Is_Digit); + + Test_Str : String := "abcde,./;'fghi[]=-^563"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (14, Packrat.Success); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (10, Packrat.Success); + Result4 : Slexy.Combinator_Result := + Slebug.Create_Result (19, Packrat.Success); + Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail; + Result6 : Slexy.Combinator_Result := + Slebug.Create_Result (22, Packrat.Optional_More); + begin + if Take_Letters (Test_Str, 2) /= Result1 or + Take_Letters (Test_Str, 13) /= Result2 or + Take_Punch (Test_Str, 6) /= Result3 or + Take_Punch (Test_Str, 17) /= Result4 or + Take_Letters (Test_Str, 7) /= Result5 or + Take_Punch (Test_Str, Test_Str'Last + 5) /= Result5 or + Take_Digits (Test_Str, 20) /= Result6 + then + return Fail; + end if; + return Pass; + end Take_While_Check; + + + function Take_Until_Check + return Test_Result + is + function Take_Till_Punch is new Slexy.Take_Until (PU.Is_Punctuation); + function Take_Till_Digit is new Slexy.Take_Until (PU.Is_Digit); + + Test_Str : String := "abcde12345;;;fghi67"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (10, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (19, Packrat.Optional_More); + Result3 : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Result4 : Slexy.Combinator_Result := + Slebug.Create_Result (17, Packrat.Success); + Result5 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if Take_Till_Punch (Test_Str, 4) /= Result1 or + Take_Till_Punch (Test_Str, 16) /= Result2 or + Take_Till_Digit (Test_Str, 1) /= Result3 or + Take_Till_Digit (Test_Str, 12) /= Result4 or + Take_Till_Punch (Test_Str, 11) /= Result5 or + Take_Till_Punch (Test_Str, Test_Str'Last + 5) /= Result5 + then + return Fail; + end if; + return Pass; + end Take_Until_Check; + + + function Line_End_Check + return Test_Result + is + function LF_End is new Slexy.Line_End (Latin.LF); + function C_End is new Slexy.Line_End ('c'); + + Test_Str : String := "abcd" & Latin.LF & "e"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if LF_End (Test_Str, 5) /= Result1 or C_End (Test_Str, 3) /= Result2 or + LF_End (Test_Str, Test_Str'Last + 5) /= Result3 or LF_End (Test_Str, 1) /= Result3 + then + return Fail; + end if; + return Pass; + end Line_End_Check; + + + function Input_End_Check + return Test_Result + is + function C_End is new Slexy.Input_End ('c'); + function E_End is new Slexy.Input_End ('e'); + + Test_Str : String := "abcde"; + + Result1 : Slexy.Combinator_Result := + Slebug.Create_Result (5, Packrat.Success); + Result2 : Slexy.Combinator_Result := + Slebug.Create_Result (3, Packrat.Success); + Result3 : Slexy.Combinator_Result := Slebug.Empty_Fail; + begin + if C_End (Test_Str, 3) /= Result2 or E_End (Test_Str, 5) /= Result1 or + C_End (Test_Str, 6) /= Result3 or E_End (Test_Str, 6) /= Result3 or + C_End (Test_Str, 1) /= Result3 or E_End (Test_Str, Test_Str'Last + 5) /= Result3 + then + return Fail; + end if; + return Pass; + end Input_End_Check; + + + + + + function Stamp_Check + return Test_Result + is + use type Slexy_Traits.Tokens.Token; + use type Packrat.Result_Status; + use type Slexy.Component_Result; + + function Match_A is new Slexy.Match ('a'); + function Match_B is new Slexy.Match ('b'); + function Match_C is new Slexy.Match ('c'); + function Seq_Abc is new Slexy.Sequence + ((Match_A'Unrestricted_Access, + Match_B'Unrestricted_Access, + Match_C'Unrestricted_Access)); + function My_Stamp is new Slexy.Stamp (One, Seq_Abc); + + Test_Str1 : String := "abcdefghi"; + Test_Str2 : String := "ab"; + + Context1 : Slexy.Lexer_Context := Slexy.Empty_Context; + Context2 : Slexy.Lexer_Context := Slexy.Empty_Context; + + Comp_Code : Slexy.Component_Result; + begin + Comp_Code := My_Stamp (Test_Str1, Context1); + if (Slebug.So_Far (Context1).Length /= 1 or else + Slebug.So_Far (Context1).Element (1) /= Slexy_Traits.Tokens.Create (One, 1, "abc")) or + Slebug.Position (Context1) /= 4 or Slebug.Status (Context1) /= Packrat.Success or + Slebug.Has_Pass (Context1) + then + return Fail; + end if; + Comp_Code := My_Stamp (Test_Str1, Context1); + if (Slebug.So_Far (Context1).Length /= 1 or else + Slebug.So_Far (Context1).Element (1) /= Slexy_Traits.Tokens.Create (One, 1, "abc")) or + Slebug.Position (Context1) /= 4 or not Slebug.Is_Failure (Comp_Code) or + Slebug.Has_Pass (Context1) + then + return Fail; + end if; + Comp_Code := My_Stamp (Test_Str2, Context2); + if Slebug.So_Far (Context2).Length /= 0 or + Slebug.Position (Context2) /= 1 or + Slebug.Status (Context2) /= Packrat.Needs_More or + (not Slebug.Has_Pass (Context2) or else Slebug.Pass (Context2) /= "ab") + then + return Fail; + end if; + return Pass; + end Stamp_Check; + + + function Ignore_Check + return Test_Result + is + use type Packrat.Result_Status; + + function Match_Abc is new Slexy.Multimatch ("abc"); + function My_Ignore is new Slexy.Ignore (Two, Match_Abc); + + Test_Str1 : String := "abcdefghi"; + Test_Str2 : String := "ab"; + + Context1 : Slexy.Lexer_Context := Slexy.Empty_Context; + Context2 : Slexy.Lexer_Context := Slexy.Empty_Context; + + Comp_Code : Slexy.Component_Result; + begin + Comp_Code := My_Ignore (Test_Str1, Context1); + if Slebug.So_Far (Context1).Length /= 0 or + Slebug.Position (Context1) /= 4 or Slebug.Status (Context1) /= Packrat.Success or + Slebug.Has_Pass (Context1) + then + return Fail; + end if; + Comp_Code := My_Ignore (Test_Str1, Context1); + if Slebug.So_Far (Context1).Length /= 0 or + Slebug.Position (Context1) /= 4 or not Slebug.Is_Failure (Comp_Code) or + Slebug.Has_Pass (Context1) + then + return Fail; + end if; + Comp_Code := My_Ignore (Test_Str2, Context2); + if Slebug.So_Far (Context2).Length /= 0 or + Slebug.Position (Context2) /= 1 or Slebug.Status (Context2) /= Packrat.Needs_More or + (not Slebug.Has_Pass (Context2) or else Slebug.Pass (Context2) /= "ab") + then + return Fail; + end if; + return Pass; + end Ignore_Check; + + + + + + type Word_Enum is (Blank, Word, Whitespace); + + package Swordy_Traits is new Packrat.Traits (Word_Enum, Character, String); + package Swordy is new Packrat.Lexers (Swordy_Traits); + package Swolbug is new Swordy.Debug; + + use type Swordy_Traits.Tokens.Token; + use type Swordy_Traits.Tokens.Token_Array; + + function Satisfy_Letter is new Swordy.Satisfy (PU.Is_Letter); + function Many_Letter is new Swordy.Many (Satisfy_Letter, 1); + function Satisfy_Whitespace is new Swordy.Satisfy (PU.Is_Whitespace); + function Many_Whitespace is new Swordy.Many (Satisfy_Whitespace, 1); + + function Stamp_Word is new Swordy.Stamp (Word, Many_Letter); + function Ignore_Whitespace is new Swordy.Ignore (Whitespace, Many_Whitespace); + + + function Scan_Check + return Test_Result + is + function My_Scan is new Swordy.Scan + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Str : String := "one fine day"; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Intended_Result1 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"), + 2 => Swordy_Traits.Tokens.Create (Word, 5, "fine")); + Intended_Result2 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 10, "day")); + + Actual_Result1 : Swordy_Traits.Tokens.Token_Array := + My_Scan (Test_Str, Test_Context); + Actual_Result2 : Swordy_Traits.Tokens.Token_Array := + My_Scan ("", Test_Context); + begin + if Actual_Result1 /= Intended_Result1 or Actual_Result2 /= Intended_Result2 then + return Fail; + end if; + return Pass; + end Scan_Check; + + + function Scan_Only_Check + return Test_Result + is + function My_Scan is new Swordy.Scan_Only + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Str : String := "one fine day"; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Intended_Result : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"), + 2 => Swordy_Traits.Tokens.Create (Word, 5, "fine"), + 3 => Swordy_Traits.Tokens.Create (Word, 10, "day")); + + Actual_Result : Swordy_Traits.Tokens.Token_Array := + My_Scan (Test_Str, Test_Context); + begin + if Actual_Result /= Intended_Result then + return Fail; + end if; + return Pass; + end Scan_Only_Check; + + + function Scan_With_Check + return Test_Result + is + Sentinel : Natural := 2; + function More_Input + return String is + begin + if Sentinel > 1 then + Sentinel := 1; + return "it will happen again"; + elsif Sentinel > 0 then + Sentinel := 0; + return " and again and again"; + else + return ""; + end if; + end More_Input; + + function My_Scan is new Swordy.Scan_With + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Intended_Result : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 1, "it"), + 2 => Swordy_Traits.Tokens.Create (Word, 4, "will"), + 3 => Swordy_Traits.Tokens.Create (Word, 9, "happen"), + 4 => Swordy_Traits.Tokens.Create (Word, 17, "again"), + 5 => Swordy_Traits.Tokens.Create (Word, 23, "and"), + 6 => Swordy_Traits.Tokens.Create (Word, 27, "again"), + 7 => Swordy_Traits.Tokens.Create (Word, 33, "and"), + 8 => Swordy_Traits.Tokens.Create (Word, 37, "again")); + + Actual_Result : Swordy_Traits.Tokens.Token_Array := + My_Scan (More_Input'Unrestricted_Access, Test_Context); + begin + if Actual_Result /= Intended_Result then + return Fail; + end if; + return Pass; + end Scan_With_Check; + + + function Scan_Set_Check + return Test_Result + is + procedure My_Scan is new Swordy.Scan_Set + ((Stamp_Word'Access, Ignore_Whitespace'Access), + Latin.EOT, Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Test_Str1 : String (1 .. 10) := "one tw"; + Test_Str2 : String (1 .. 10) := "o three"; + Test_Str3 : String (1 .. 10) := Latin.EOT & " "; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Intended_Result1 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 1, "one"), + 2 => Swordy_Traits.Tokens.Create (Blank, 1, ""), + 3 => Swordy_Traits.Tokens.Create (Blank, 1, "")); + Intended_Result2 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 9, "two"), + 2 => Swordy_Traits.Tokens.Create (Blank, 1, ""), + 3 => Swordy_Traits.Tokens.Create (Blank, 1, "")); + Intended_Result3 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 16, "three"), + 2 => Swordy_Traits.Tokens.Create (Blank, 1, ""), + 3 => Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Actual_Result : Swordy_Traits.Tokens.Token_Array (1 .. 3); + begin + My_Scan (Test_Str1, Test_Context, Actual_Result); + if Actual_Result /= Intended_Result1 then + return Fail; + end if; + My_Scan (Test_Str2, Test_Context, Actual_Result); + if Actual_Result /= Intended_Result2 then + return Fail; + end if; + My_Scan (Test_Str3, Test_Context, Actual_Result); + if Actual_Result /= Intended_Result3 then + return Fail; + end if; + return Pass; + end Scan_Set_Check; + + + function Scan_Set_With_Check + return Test_Result + is + Sentinel : Natural := 2; + function More_Input + return String is + begin + if Sentinel > 1 then + Sentinel := 1; + return "it will happen again"; + elsif Sentinel > 0 then + Sentinel := 0; + return " and again and again"; + else + return ""; + end if; + end More_Input; + + procedure My_Scan is new Swordy.Scan_Set_With + ((Stamp_Word'Access, Ignore_Whitespace'Access), + Latin.EOT, Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Intended_Result1 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 1, "it"), + 2 => Swordy_Traits.Tokens.Create (Word, 4, "will"), + 3 => Swordy_Traits.Tokens.Create (Word, 9, "happen"), + 4 => Swordy_Traits.Tokens.Create (Word, 16, "again"), + 5 => Swordy_Traits.Tokens.Create (Word, 22, "and")); + Intended_Result2 : Swordy_Traits.Tokens.Token_Array := + (1 => Swordy_Traits.Tokens.Create (Word, 26, "again"), + 2 => Swordy_Traits.Tokens.Create (Word, 32, "and"), + 3 => Swordy_Traits.Tokens.Create (Word, 36, "again"), + 4 => Swordy_Traits.Tokens.Create (Blank, 1, ""), + 5 => Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Actual_Result : Swordy_Traits.Tokens.Token_Array (1 .. 5); + begin + My_Scan (More_Input'Unrestricted_Access, Test_Context, Actual_Result); + if Actual_Result /= Intended_Result1 then + return Fail; + end if; + My_Scan (More_Input'Unrestricted_Access, Test_Context, Actual_Result); + if Actual_Result /= Intended_Result2 then + return Fail; + end if; + return Pass; + end Scan_Set_With_Check; + + + function Scan_Error_Check + return Test_Result + is + use type Packrat.Errors.Error_Info_Array; + + function My_Scan is new Swordy.Scan + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Str : String := "()()"; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Expected_Errors : Packrat.Errors.Error_Info_Array := + ((+"WORD", 1), (+"WHITESPACE", 1)); + begin + declare + Result : Swordy_Traits.Tokens.Token_Array := My_Scan (Test_Str, Test_Context); + begin + return Fail; + end; + exception + when Msg : Packrat.Lexer_Error => + if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then + return Fail; + end if; + return Pass; + end Scan_Error_Check; + + + function Scan_Only_Error_Check + return Test_Result + is + use type Packrat.Errors.Error_Info_Array; + + function My_Scan is new Swordy.Scan_Only + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Str : String := "()()"; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Expected_Errors : Packrat.Errors.Error_Info_Array := + ((+"WORD", 1), (+"WHITESPACE", 1)); + begin + declare + Result : Swordy_Traits.Tokens.Token_Array := My_Scan (Test_Str, Test_Context); + begin + return Fail; + end; + exception + when Msg : Packrat.Lexer_Error => + if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then + return Fail; + end if; + return Pass; + end Scan_Only_Error_Check; + + + function Scan_With_Error_Check + return Test_Result + is + use type Packrat.Errors.Error_Info_Array; + + Sentinel : Integer := 1; + function Get_Input + return String is + begin + if Sentinel > 0 then + Sentinel := 0; + return "()()"; + else + return ""; + end if; + end Get_Input; + + function My_Scan is new Swordy.Scan_With + ((Stamp_Word'Access, Ignore_Whitespace'Access)); + + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Expected_Errors : Packrat.Errors.Error_Info_Array := + ((+"WORD", 1), (+"WHITESPACE", 1)); + begin + declare + Result : Swordy_Traits.Tokens.Token_Array := + My_Scan (Get_Input'Unrestricted_Access, Test_Context); + begin + return Fail; + end; + exception + when Msg : Packrat.Lexer_Error => + if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then + return Fail; + end if; + return Pass; + end Scan_With_Error_Check; + + + function Scan_Set_Error_Check + return Test_Result + is + use type Packrat.Errors.Error_Info_Array; + + procedure My_Scan is new Swordy.Scan_Set + ((Stamp_Word'Access, Ignore_Whitespace'Access), + Latin.EOT, Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Test_Str : String := "()()"; + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Result : Swordy_Traits.Tokens.Token_Array (1 .. 5); + + Expected_Errors : Packrat.Errors.Error_Info_Array := + ((+"WORD", 1), (+"WHITESPACE", 1)); + begin + My_Scan (Test_Str, Test_Context, Result); + return Fail; + exception + when Msg : Packrat.Lexer_Error => + if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then + return Fail; + end if; + return Pass; + end Scan_Set_Error_Check; + + + function Scan_Set_With_Error_Check + return Test_Result + is + use type Packrat.Errors.Error_Info_Array; + + Sentinel : Integer := 1; + function Get_Input + return String is + begin + if Sentinel > 0 then + Sentinel := 0; + return "()()"; + else + return ""; + end if; + end Get_Input; + + procedure My_Scan is new Swordy.Scan_Set_With + ((Stamp_Word'Access, Ignore_Whitespace'Access), + Latin.EOT, Swordy_Traits.Tokens.Create (Blank, 1, "")); + + Test_Context : Swordy.Lexer_Context := Swordy.Empty_Context; + + Result : Swordy_Traits.Tokens.Token_Array (1 .. 5); + + Expected_Errors : Packrat.Errors.Error_Info_Array := + ((+"WORD", 1), (+"WHITESPACE", 1)); + begin + My_Scan (Get_Input'Unrestricted_Access, Test_Context, Result); + return Fail; + exception + when Msg : Packrat.Lexer_Error => + if Packrat.Errors.Decode (Except.Exception_Message (Msg)) /= Expected_Errors then + return Fail; + end if; + return Pass; + end Scan_Set_With_Error_Check; + + +end Rat_Tests.Lexers; + + -- cgit