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;