ambiguous_case!(
testambigparsetrees_testambigaltdipsintooutercontextbelowroot_0b56365d67,
"testambigparsetrees-testambigaltdipsintooutercontextbelowroot-0b56365d67",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "s", decision: 1, input_index: 0, input: "self.x", overall: Some("(s:1 (e:1 (p:1 self) . x))"), alternatives: &[(1, "(e:1 (p:1 self) . x)"), (2, "(p:2 self . x)")] },
],
);
ambiguous_case!(
testambigparsetrees_testambigaltdipsintooutercontexttoroot_6be37f9c93,
"testambigparsetrees-testambigaltdipsintooutercontexttoroot-6be37f9c93",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "e", decision: 1, input_index: 0, input: "self.x", overall: Some("(e:1 (p:1 self) . x)"), alternatives: &[(1, "(e:1 (p:1 self) . x)"), (2, "(p:2 self . x)")] },
],
);
ambiguous_case!(
testambigparsetrees_testambigaltinleftrecursivebelowstartrule_06084993e4,
"testambigparsetrees-testambigaltinleftrecursivebelowstartrule-06084993e4",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "s", decision: 1, input_index: 0, input: "self.x", overall: Some("(s:1 (e:2 (e:1 (p:1 self)) . x))"), alternatives: &[(1, "(e:2 (e:1 (p:1 self)) . x)"), (2, "(p:2 self . x)")] },
],
);
ambiguous_case!(
testambigparsetrees_testambigaltinleftrecursivestartrule_7d8c05bffe,
"testambigparsetrees-testambigaltinleftrecursivestartrule-7d8c05bffe",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "e", decision: 1, input_index: 0, input: "self.x", overall: Some("(e:2 (e:1 (p:1 self)) . x)"), alternatives: &[(1, "(e:2 (e:1 (p:1 self)) . x)"), (2, "(p:2 self . x)")] },
],
);
ambiguous_case!(
testambigparsetrees_testambigaltsatroot_b14e3cb45c,
"testambigparsetrees-testambigaltsatroot-b14e3cb45c",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "s", decision: 0, input_index: 0, input: "abc", overall: Some("(s:1 a (x:1 b) c)"), alternatives: &[(1, "(s:1 a (x:1 b) c)"), (2, "(s:2 a b c)")] },
],
);
ambiguous_case!(
testambigparsetrees_testambigaltsnotatroot_db08a05a06,
"testambigparsetrees-testambigaltsnotatroot-db08a05a06",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "s", decision: 0, input_index: 0, input: "abc", overall: Some("(s:1 (x:1 (y:1 a (z:1 b) c)))"), alternatives: &[(1, "(y:1 a (z:1 b) c)"), (2, "(y:2 a b c)")] },
],
);
ambiguous_case!(
testambigparsetrees_testparsedecisionwithinambiguousstartrule_5084fb93b6,
"testambigparsetrees-testparsedecisionwithinambiguousstartrule-5084fb93b6",
&["L.g4", "T.g4"],
&[
AmbiguousCheck { start_rule: "s", decision: 0, input_index: 0, input: "abc", overall: None, alternatives: &[(1, "(s:1 a (x:1 b) c)")] },
AmbiguousCheck { start_rule: "s", decision: 0, input_index: 0, input: "abc", overall: None, alternatives: &[(2, "(s:2 a b c)")] },
],
);
parser_alt_case!(
testatninterpreter_testambigaltchoosefirst_f46ba63902,
"testatninterpreter-testambigaltchoosefirst-f46ba63902",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(1) },
],
);
parser_alt_case!(
testatninterpreter_testambigaltchoosefirst2_7de3baee62,
"testatninterpreter-testambigaltchoosefirst2-7de3baee62",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "abd", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abcd", expected: AltExpectation::Alternative(3) },
],
);
parser_alt_case!(
testatninterpreter_testambigaltchoosefirst2witheof_adf5400cb3,
"testatninterpreter-testambigaltchoosefirst2witheof-adf5400cb3",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "abd", expected: AltExpectation::NoViableAlt { token_index: 2, token_type: 4 } },
],
);
parser_alt_case!(
testatninterpreter_testambigaltchoosefirstwithfollowingtoken_64e8739f64,
"testatninterpreter-testambigaltchoosefirstwithfollowingtoken-64e8739f64",
&["L.g4", "T.g4"],
&[
AltCheck { input: "abc", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abcd", expected: AltExpectation::Alternative(1) },
],
);
parser_alt_case!(
testatninterpreter_testambigaltchoosefirstwithfollowingtoken2_a7a2497f39,
"testatninterpreter-testambigaltchoosefirstwithfollowingtoken2-a7a2497f39",
&["L.g4", "T.g4"],
&[
AltCheck { input: "abd", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abdc", expected: AltExpectation::Alternative(1) },
AltCheck { input: "cd", expected: AltExpectation::Alternative(3) },
],
);
parser_alt_case!(
testatninterpreter_testarbitraryleftprefix_b5329b95fd,
"testatninterpreter-testarbitraryleftprefix-b5329b95fd",
&["L.g4", "T.g4"],
&[
AltCheck { input: "aac", expected: AltExpectation::Alternative(2) },
],
);
parser_alt_case!(
testatninterpreter_testcommonleftprefix_5b65f6ca88,
"testatninterpreter-testcommonleftprefix-5b65f6ca88",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ac", expected: AltExpectation::Alternative(2) },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodalt_c9f647e58d,
"testatninterpreter-testmusttrackpreviousgoodalt-c9f647e58d",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(2) },
AltCheck { input: "ac", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(2) },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodalt2_3d7c15ffc3,
"testatninterpreter-testmusttrackpreviousgoodalt2-3d7c15ffc3",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(2) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "ad", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abd", expected: AltExpectation::Alternative(2) },
AltCheck { input: "abcd", expected: AltExpectation::Alternative(3) },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodalt2witheof_0d67ab0fb7,
"testatninterpreter-testmusttrackpreviousgoodalt2witheof-0d67ab0fb7",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(2) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "abd", expected: AltExpectation::NoViableAlt { token_index: 2, token_type: 4 } },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodalt3_c130bdb2f8,
"testatninterpreter-testmusttrackpreviousgoodalt3-c130bdb2f8",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(2) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "ad", expected: AltExpectation::Alternative(2) },
AltCheck { input: "abd", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abcd", expected: AltExpectation::Alternative(3) },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodalt3witheof_351a509f35,
"testatninterpreter-testmusttrackpreviousgoodalt3witheof-351a509f35",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(2) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(3) },
AltCheck { input: "abd", expected: AltExpectation::NoViableAlt { token_index: 2, token_type: 4 } },
],
);
parser_alt_case!(
testatninterpreter_testmusttrackpreviousgoodaltwitheof_d77964f0db,
"testatninterpreter-testmusttrackpreviousgoodaltwitheof-d77964f0db",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(2) },
AltCheck { input: "ac", expected: AltExpectation::NoViableAlt { token_index: 1, token_type: 3 } },
],
);
parser_alt_case!(
testatninterpreter_testpegachillesheel_86a37709f7,
"testatninterpreter-testpegachillesheel-86a37709f7",
&["L.g4", "T.g4"],
&[
AltCheck { input: "a", expected: AltExpectation::Alternative(1) },
AltCheck { input: "ab", expected: AltExpectation::Alternative(2) },
AltCheck { input: "abc", expected: AltExpectation::Alternative(2) },
],
);
parser_alt_case!(
testatninterpreter_testrecursiveleftprefix_d892b5605b,
"testatninterpreter-testrecursiveleftprefix-d892b5605b",
&["L.g4", "T.g4"],
&[
AltCheck { input: "34b", expected: AltExpectation::Alternative(1) },
AltCheck { input: "34c", expected: AltExpectation::Alternative(2) },
AltCheck { input: "(34)b", expected: AltExpectation::Alternative(1) },
AltCheck { input: "(34)c", expected: AltExpectation::Alternative(2) },
AltCheck { input: "((34))b", expected: AltExpectation::Alternative(1) },
AltCheck { input: "((34))c", expected: AltExpectation::Alternative(2) },
],
);
parser_alt_case!(
testatninterpreter_testset_5431f26c69,
"testatninterpreter-testset-5431f26c69",
&["L.g4", "T.g4"],
&[
AltCheck { input: "b", expected: AltExpectation::Alternative(1) },
],
);
parser_alt_case!(
testatninterpreter_testsimpleloop_dd29ae159d,
"testatninterpreter-testsimpleloop-dd29ae159d",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "aab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "aaaaaab", expected: AltExpectation::Alternative(1) },
AltCheck { input: "aabd", expected: AltExpectation::Alternative(1) },
],
);
parser_alt_case!(
testatninterpreter_testsimplenoblock_bdbf4cfabe,
"testatninterpreter-testsimplenoblock-bdbf4cfabe",
&["L.g4", "T.g4"],
&[
AltCheck { input: "ab", expected: AltExpectation::Alternative(1) },
],
);
lexer_case!(
testatnlexerinterpreter_testcaseinsensitiveinlexerrule_b5aa50f0d0,
"testatnlexerinterpreter-testcaseinsensitiveinlexerrule-b5aa50f0d0",
&["L.g4"],
&[
LexerCheck { input: "ABCDEF", expected: Some(&["TOKEN1", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testcaseinsensitiveinlexerruleoverridesglobalvalue_dea4d25945,
"testatnlexerinterpreter-testcaseinsensitiveinlexerruleoverridesglobalvalue-dea4d25945",
&["L.g4"],
&[
LexerCheck { input: "n'sample'", expected: None, errors: &["line 1:0 token recognition error at: 'n'"] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofatendoflinecomment_5ae9ae8ced,
"testatnlexerinterpreter-testeofatendoflinecomment-5ae9ae8ced",
&["L.g4"],
&[
LexerCheck { input: "//x", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofatendoflinecomment2_e29a7a51b0,
"testatnlexerinterpreter-testeofatendoflinecomment2-e29a7a51b0",
&["L.g4"],
&[
LexerCheck { input: "//x", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofbyitself_37fa7d4737,
"testatnlexerinterpreter-testeofbyitself-37fa7d4737",
&["L.g4"],
&[
LexerCheck { input: "a", expected: Some(&["A", "DONE", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofinsetatendoflinecomment_1bd0192f46,
"testatnlexerinterpreter-testeofinsetatendoflinecomment-1bd0192f46",
&["L.g4"],
&[
LexerCheck { input: "//", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofsuffixinfirstrule_758873ff9c,
"testatnlexerinterpreter-testeofsuffixinfirstrule-758873ff9c",
&["L.g4"],
&[
LexerCheck { input: "a", expected: Some(&["A", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testeofsuffixinsecondrule_ff13b17a5a,
"testatnlexerinterpreter-testeofsuffixinsecondrule-ff13b17a5a",
&["L.g4"],
&[
LexerCheck { input: "a", expected: Some(&["B", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testgreedybetweenrules_5a20e79691,
"testatnlexerinterpreter-testgreedybetweenrules-5a20e79691",
&["L.g4"],
&[
LexerCheck { input: "<a><x>", expected: Some(&["B", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexercaseinsensitive_c77e1048a1,
"testatnlexerinterpreter-testlexercaseinsensitive-c77e1048a1",
&["L.g4"],
&[
LexerCheck { input: "and AND aND\nasdf ASDF\nint64\ntoken_WITH_underscore\nTRUE FALSE\n==\nA0bcDE93\nАБВабв\n", expected: Some(&["SIMPLE_TOKEN", "SIMPLE_TOKEN", "SIMPLE_TOKEN", "TOKEN_WITH_SPACES", "TOKEN_WITH_SPACES", "TOKEN_WITH_DIGITS", "TOKEN_WITH_UNDERSCORE", "BOOL", "BOOL", "SPECIAL", "SET", "RANGE", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexercaseinsensitivefragments_a467dc676c,
"testatnlexerinterpreter-testlexercaseinsensitivefragments-a467dc676c",
&["L.g4"],
&[
LexerCheck { input: "ABCDDD", expected: Some(&["TOKEN_0", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexercaseinsensitiveliteralwithnegation_47d2272cfa,
"testatnlexerinterpreter-testlexercaseinsensitiveliteralwithnegation-47d2272cfa",
&["L.g4"],
&[
LexerCheck { input: "F", expected: None, errors: &["line 1:0 token recognition error at: 'F'"] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexercaseinsensitivesetwithnegation_279b187396,
"testatnlexerinterpreter-testlexercaseinsensitivesetwithnegation-279b187396",
&["L.g4"],
&[
LexerCheck { input: "B", expected: None, errors: &["line 1:0 token recognition error at: 'B'"] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexercaseinsensitivewithdifferentcultures_c3e6a963f7,
"testatnlexerinterpreter-testlexercaseinsensitivewithdifferentcultures-c3e6a963f7",
&["L.g4"],
&[
LexerCheck { input: "abcXYZ äéöüßÄÉÖÜß àâæçÙÛÜŸ ćčđĐŠŽ àèéÌÒÙ áéÚÜ¡¿ αβγΧΨΩ абвЭЮЯ ", expected: Some(&["ENGLISH_TOKEN", "GERMAN_TOKEN", "FRENCH_TOKEN", "CROATIAN_TOKEN", "ITALIAN_TOKEN", "SPANISH_TOKEN", "GREEK_TOKEN", "RUSSIAN_TOKEN", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerescapeinstring_d6fecbac81,
"testatnlexerinterpreter-testlexerescapeinstring-d6fecbac81",
&["L.g4"],
&[
LexerCheck { input: "[a~]b]", expected: Some(&["STR", "EOF"]), errors: &[] },
LexerCheck { input: "[a]", expected: Some(&["STR", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexergreedyoptionalshouldworkasweexpect_f56c9ac4c1,
"testatnlexerinterpreter-testlexergreedyoptionalshouldworkasweexpect-f56c9ac4c1",
&["L.g4"],
&[
LexerCheck { input: "/**/", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerkeywordidambiguity_6a26e2f5b0,
"testatnlexerinterpreter-testlexerkeywordidambiguity-6a26e2f5b0",
&["L.g4"],
&[
LexerCheck { input: "end", expected: Some(&["KEND", "EOF"]), errors: &[] },
LexerCheck { input: "ending", expected: Some(&["ID", "EOF"]), errors: &[] },
LexerCheck { input: "a end bcd", expected: Some(&["ID", "WS", "KEND", "WS", "ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerloops_2c4db4e174,
"testatnlexerinterpreter-testlexerloops-2c4db4e174",
&["L.g4"],
&[
LexerCheck { input: "a34bde3", expected: Some(&["ID", "INT", "ID", "INT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotbmpsetmatchesbmp_1503c9d033,
"testatnlexerinterpreter-testlexernotbmpsetmatchesbmp-1503c9d033",
&["L.g4"],
&[
LexerCheck { input: "愛", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotbmpsetmatchessmp_5fc577380c,
"testatnlexerinterpreter-testlexernotbmpsetmatchessmp-5fc577380c",
&["L.g4"],
&[
LexerCheck { input: "💩", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotbmpsetmatchesunicodesmp_0f84a2e75d,
"testatnlexerinterpreter-testlexernotbmpsetmatchesunicodesmp-0f84a2e75d",
&["L.g4"],
&[
LexerCheck { input: "💩", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotset_2448dbbeaf,
"testatnlexerinterpreter-testlexernotset-2448dbbeaf",
&["L.g4"],
&[
LexerCheck { input: "c", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotsetunicodebmp_db75867764,
"testatnlexerinterpreter-testlexernotsetunicodebmp-db75867764",
&["L.g4"],
&[
LexerCheck { input: "愝", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotsetunicodebmpmatchessmp_f7c7d5c0c3,
"testatnlexerinterpreter-testlexernotsetunicodebmpmatchessmp-f7c7d5c0c3",
&["L.g4"],
&[
LexerCheck { input: "💩", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotsmpsetmatchesbmp_cae63add90,
"testatnlexerinterpreter-testlexernotsmpsetmatchesbmp-cae63add90",
&["L.g4"],
&[
LexerCheck { input: "愛", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexernotsmpsetmatchessmp_c4ce6fa5a0,
"testatnlexerinterpreter-testlexernotsmpsetmatchessmp-c4ce6fa5a0",
&["L.g4"],
&[
LexerCheck { input: "𝟀", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerrangeunicodebmptosmp_d1f9d6d65c,
"testatnlexerinterpreter-testlexerrangeunicodebmptosmp-d1f9d6d65c",
&["L.g4"],
&[
LexerCheck { input: "𒀁", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerrangeunicodesmp_04d22ca57e,
"testatnlexerinterpreter-testlexerrangeunicodesmp-04d22ca57e",
&["L.g4"],
&[
LexerCheck { input: "💯", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerruleref_7dadd2da18,
"testatnlexerinterpreter-testlexerruleref-7dadd2da18",
&["L.g4"],
&[
LexerCheck { input: "32 99", expected: Some(&["INT", "WS", "INT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexersetunicodebmp_ab2e06b474,
"testatnlexerinterpreter-testlexersetunicodebmp-ab2e06b474",
&["L.g4"],
&[
LexerCheck { input: "愛", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexersetunicodesmp_dfa3e51295,
"testatnlexerinterpreter-testlexersetunicodesmp-dfa3e51295",
&["L.g4"],
&[
LexerCheck { input: "💩", expected: Some(&["ID", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexertworules_eeaf9e9f11,
"testatnlexerinterpreter-testlexertworules-eeaf9e9f11",
&["L.g4"],
&[
LexerCheck { input: "abab", expected: Some(&["A", "B", "A", "B", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerwildcardexplicitnongreedyplusloop_fb4a7dc4b6,
"testatnlexerinterpreter-testlexerwildcardexplicitnongreedyplusloop-fb4a7dc4b6",
&["L.g4"],
&[
LexerCheck { input: "//x\n//y\n", expected: Some(&["CMT", "CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerwildcardgreedyloopbydefault_90523bdff6,
"testatnlexerinterpreter-testlexerwildcardgreedyloopbydefault-90523bdff6",
&["L.g4"],
&[
LexerCheck { input: "//x\n//y\n", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerwildcardgreedyplusloopbydefault_c49a1198b5,
"testatnlexerinterpreter-testlexerwildcardgreedyplusloopbydefault-c49a1198b5",
&["L.g4"],
&[
LexerCheck { input: "//x\n//y\n", expected: Some(&["CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testlexerwildcardloopexplicitnongreedy_26dd6b81c8,
"testatnlexerinterpreter-testlexerwildcardloopexplicitnongreedy-26dd6b81c8",
&["L.g4"],
&[
LexerCheck { input: "//x\n//y\n", expected: Some(&["CMT", "CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testnongreedybetweenrules_0aac41713c,
"testatnlexerinterpreter-testnongreedybetweenrules-0aac41713c",
&["L.g4"],
&[
LexerCheck { input: "<a><x>", expected: Some(&["A", "B", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testnotimpliedcharacterswithenabledcaseinsensitiveoption_7c2edd09df,
"testatnlexerinterpreter-testnotimpliedcharacterswithenabledcaseinsensitiveoption-7c2edd09df",
&["L.g4"],
&[
LexerCheck { input: "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz", expected: Some(&["TOKEN", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testrecursivelexerruleref_2047e777de,
"testatnlexerinterpreter-testrecursivelexerruleref-2047e777de",
&["L.g4"],
&[
LexerCheck { input: "/* ick */\n/* /*nested*/ */", expected: Some(&["CMT", "WS", "CMT", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testrecursivelexerrulerefwithwildcard_b355598a51,
"testatnlexerinterpreter-testrecursivelexerrulerefwithwildcard-b355598a51",
&["L.g4"],
&[
LexerCheck { input: "/* ick */\n/* /* */\n/* /*nested*/ */\n", expected: Some(&["CMT", "WS", "CMT", "WS", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testshortlongrule_c63fa23669,
"testatnlexerinterpreter-testshortlongrule-c63fa23669",
&["L.g4"],
&[
LexerCheck { input: "xy", expected: Some(&["A", "EOF"]), errors: &[] },
LexerCheck { input: "xyz", expected: Some(&["A", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testshortlongrule2_c0830bbdf2,
"testatnlexerinterpreter-testshortlongrule2-c0830bbdf2",
&["L.g4"],
&[
LexerCheck { input: "xy", expected: Some(&["A", "EOF"]), errors: &[] },
LexerCheck { input: "xyz", expected: Some(&["A", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testwildcardnonquirkwhensplitbetweentworules_c4c32ab4bb,
"testatnlexerinterpreter-testwildcardnonquirkwhensplitbetweentworules-c4c32ab4bb",
&["L.g4"],
&[
LexerCheck { input: "xy", expected: Some(&["A", "EOF"]), errors: &[] },
LexerCheck { input: "xyqz", expected: Some(&["B", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testwildonendfirstalt_fc445bf7e5,
"testatnlexerinterpreter-testwildonendfirstalt-fc445bf7e5",
&["L.g4"],
&[
LexerCheck { input: "xy", expected: Some(&["A", "EOF"]), errors: &[] },
LexerCheck { input: "xyz", expected: Some(&["A", "EOF"]), errors: &[] },
],
);
lexer_case!(
testatnlexerinterpreter_testwildonendlastalt_da8a95ac4b,
"testatnlexerinterpreter-testwildonendlastalt-da8a95ac4b",
&["L.g4"],
&[
LexerCheck { input: "xy", expected: Some(&["A", "EOF"]), errors: &[] },
LexerCheck { input: "xyz", expected: Some(&["A", "EOF"]), errors: &[] },
],
);
left_recursion_alts_case!(
testatnparserprediction_testaltsforlrrulecomputation_f05d07aee9,
"testatnparserprediction-testaltsforlrrulecomputation-f05d07aee9",
&["T.g4"],
"e",
&[0, 2, 4],
&[0, 1, 3],
);
left_recursion_alts_case!(
testatnparserprediction_testaltsforlrrulecomputation2_32a72b0af8,
"testatnparserprediction-testaltsforlrrulecomputation2-32a72b0af8",
&["T.g4"],
"e",
&[0, 1, 3],
&[0, 2],
);
left_recursion_alts_case!(
testatnparserprediction_testaltsforlrrulecomputation3_abc9bbb2ff,
"testatnparserprediction-testaltsforlrrulecomputation3-abc9bbb2ff",
&["T.g4"],
"e",
&[0, 1, 5],
&[0, 2, 3, 4],
);
prediction_case!(
testatnparserprediction_testaorb_32d8c778d2,
"testatnparserprediction-testaorb-32d8c778d2",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "b", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["a", "b", "a"], expected: &["s0-'a'->:s1=>1\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\n"] },
],
);
prediction_case!(
testatnparserprediction_testcontinueprediction_1dbc43e8ad,
"testatnparserprediction-testcontinueprediction-1dbc43e8ad",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 1, input: "a;", expected: 1 },
PredictionCheck { decision: 1, input: "ab;", expected: 2 },
],
&[
],
);
prediction_case!(
testatnparserprediction_testcontinueprediction2_b1afa09fd5,
"testatnparserprediction-testcontinueprediction2-b1afa09fd5",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "a;", expected: 3 },
],
&[
],
);
prediction_case!(
testatnparserprediction_testemptyinput_06b21efabb,
"testatnparserprediction-testemptyinput-06b21efabb",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["a", ""], expected: &["s0-'a'->:s1=>1\n", "s0-EOF->:s2=>2\ns0-'a'->:s1=>1\n"] },
],
);
prediction_case!(
testatnparserprediction_testll1ambig_f17d128ca5,
"testatnparserprediction-testll1ambig-f17d128ca5",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "ab", expected: 3 },
],
&[
DfaCheck { decision: 0, inputs: &["a", "ab", "ab"], expected: &["s0-'a'->s1\ns1-EOF->:s2^=>1\n", "s0-'a'->s1\ns1-EOF->:s2^=>1\ns1-'b'->:s3=>3\n", "s0-'a'->s1\ns1-EOF->:s2^=>1\ns1-'b'->:s3=>3\n"] },
],
);
prediction_case!(
testatnparserprediction_testll2ambig_30894d8c6f,
"testatnparserprediction-testll2ambig-30894d8c6f",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "ab", expected: 1 },
PredictionCheck { decision: 0, input: "abc", expected: 3 },
],
&[
DfaCheck { decision: 0, inputs: &["ab", "abc", "ab"], expected: &["s0-'a'->s1\ns1-'b'->s2\ns2-EOF->:s3^=>1\n", "s0-'a'->s1\ns1-'b'->s2\ns2-EOF->:s3^=>1\ns2-'c'->:s4=>3\n", "s0-'a'->s1\ns1-'b'->s2\ns2-EOF->:s3^=>1\ns2-'c'->:s4=>3\n"] },
],
);
prediction_case!(
testatnparserprediction_testoptionalrulechasesglobalfollow_d4aa57a330,
"testatnparserprediction-testoptionalrulechasesglobalfollow-d4aa57a330",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "b", expected: 2 },
PredictionCheck { decision: 0, input: "c", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["a", "b", "c", "c"], expected: &["s0-'a'->:s1=>1\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\ns0-'c'->:s3=>2\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\ns0-'c'->:s3=>2\n"] },
],
);
prediction_case!(
testatnparserprediction_testpegachillesheel_55c9430fb5,
"testatnparserprediction-testpegachillesheel-55c9430fb5",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "ab", expected: 2 },
PredictionCheck { decision: 0, input: "abc", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["a", "ab", "abc"], expected: &["s0-'a'->s1\ns1-EOF->:s2=>1\n", "s0-'a'->s1\ns1-EOF->:s2=>1\ns1-'b'->:s3=>2\n", "s0-'a'->s1\ns1-EOF->:s2=>1\ns1-'b'->:s3=>2\n"] },
],
);
prediction_case!(
testatnparserprediction_testrecursiveleftprefix_32c4086bb3,
"testatnparserprediction-testrecursiveleftprefix-32c4086bb3",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "34b", expected: 1 },
PredictionCheck { decision: 0, input: "34c", expected: 2 },
PredictionCheck { decision: 0, input: "((34))b", expected: 1 },
PredictionCheck { decision: 0, input: "((34))c", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["34b", "34c", "((34))b", "((34))c"], expected: &["s0-INT->s1\ns1-'b'->:s2=>1\n", "s0-INT->s1\ns1-'b'->:s2=>1\ns1-'c'->:s3=>2\n", "s0-'('->s4\ns0-INT->s1\ns1-'b'->:s2=>1\ns1-'c'->:s3=>2\ns4-'('->s5\ns5-INT->s6\ns6-')'->s7\ns7-')'->s1\n", "s0-'('->s4\ns0-INT->s1\ns1-'b'->:s2=>1\ns1-'c'->:s3=>2\ns4-'('->s5\ns5-INT->s6\ns6-')'->s7\ns7-')'->s1\n"] },
],
);
prediction_case!(
testatnparserprediction_testrecursiveleftprefixwithaorabissue_9d0d2afc74,
"testatnparserprediction-testrecursiveleftprefixwithaorabissue-9d0d2afc74",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "34a", expected: 1 },
PredictionCheck { decision: 0, input: "34ab", expected: 2 },
PredictionCheck { decision: 0, input: "((34))a", expected: 1 },
PredictionCheck { decision: 0, input: "((34))ab", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["34a", "34ab", "((34))a", "((34))ab"], expected: &["s0-INT->s1\ns1-'a'->s2\ns2-EOF->:s3=>1\n", "s0-INT->s1\ns1-'a'->s2\ns2-EOF->:s3=>1\ns2-'b'->:s4=>2\n", "s0-'('->s5\ns0-INT->s1\ns1-'a'->s2\ns2-EOF->:s3=>1\ns2-'b'->:s4=>2\ns5-'('->s6\ns6-INT->s7\ns7-')'->s8\ns8-')'->s1\n", "s0-'('->s5\ns0-INT->s1\ns1-'a'->s2\ns2-EOF->:s3=>1\ns2-'b'->:s4=>2\ns5-'('->s6\ns6-INT->s7\ns7-')'->s8\ns8-')'->s1\n"] },
],
);
prediction_case!(
testatnparserprediction_testrulerefxory_d65b47f86d,
"testatnparserprediction-testrulerefxory-d65b47f86d",
&["L.g4", "T.g4"],
&[
PredictionCheck { decision: 0, input: "a", expected: 1 },
PredictionCheck { decision: 0, input: "b", expected: 2 },
],
&[
DfaCheck { decision: 0, inputs: &["a", "b", "a"], expected: &["s0-'a'->:s1=>1\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\n", "s0-'a'->:s1=>1\ns0-'b'->:s2=>2\n"] },
],
);
tool_case!(
testcodegeneration_assigntokennamestostringliteralarraysingeneratedparserrulecontexts_cd2030bed9,
"testcodegeneration-assigntokennamestostringliteralarraysingeneratedparserrulecontexts-cd2030bed9",
&["T.g4"],
ToolCase::CodegenLiteralAccessor { repeated: true },
);
tool_case!(
testcodegeneration_assigntokennamestostringliteralsingeneratedparserrulecontexts_983a5b92b8,
"testcodegeneration-assigntokennamestostringliteralsingeneratedparserrulecontexts-983a5b92b8",
&["T.g4"],
ToolCase::CodegenLiteralAccessor { repeated: false },
);
tool_case!(
testcodegeneration_csharpaccessleveloption_3bd1318d28,
"testcodegeneration-csharpaccessleveloption-3bd1318d28",
&["T.g4"],
ToolCase::CodegenAccessLevel,
);
tool_case!(
testcodegeneration_testargdecl_ced2e031e1,
"testcodegeneration-testargdecl-ced2e031e1",
&["T.g4"],
ToolCase::CodegenArgumentDeclaration,
);
parser_case!(
testgrammarparserinterpreter_testalts_22eedde0ac,
"testgrammarparserinterpreter-testalts-22eedde0ac",
&["L.g4", "T.g4"],
true,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s:1 a)", intervals: &[] },
ParserCheck { start_rule: "s", input: "3", tree: "(s:2 3)", intervals: &[] },
],
);
parser_case!(
testgrammarparserinterpreter_testaltsasset_e205eca37a,
"testgrammarparserinterpreter-testaltsasset-e205eca37a",
&["L.g4", "T.g4"],
true,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s:1 a)", intervals: &[] },
ParserCheck { start_rule: "s", input: "3", tree: "(s:1 3)", intervals: &[] },
],
);
parser_case!(
testgrammarparserinterpreter_testaltswithlabels_af19668d8d,
"testgrammarparserinterpreter-testaltswithlabels-af19668d8d",
&["L.g4", "T.g4"],
true,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s:1 a)", intervals: &[] },
ParserCheck { start_rule: "s", input: "3", tree: "(s:2 3)", intervals: &[] },
],
);
parser_case!(
testgrammarparserinterpreter_testleftrecursionwithmultipleprimaryandrecursiveops_092e21365b,
"testgrammarparserinterpreter-testleftrecursionwithmultipleprimaryandrecursiveops-092e21365b",
&["L.g4", "T.g4"],
true,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s:1 (e:4 a) <EOF>)", intervals: &[] },
ParserCheck { start_rule: "e", input: "a", tree: "(e:4 a)", intervals: &[] },
ParserCheck { start_rule: "e", input: "34", tree: "(e:3 34)", intervals: &[] },
ParserCheck { start_rule: "e", input: "a+1", tree: "(e:2 (e:4 a) + (e:3 1))", intervals: &[] },
ParserCheck { start_rule: "e", input: "1+2*a", tree: "(e:2 (e:3 1) + (e:1 (e:3 2) * (e:4 a)))", intervals: &[] },
],
);
parser_case!(
testgrammarparserinterpreter_testonealt_137e50ed33,
"testgrammarparserinterpreter-testonealt-137e50ed33",
&["L.g4", "T.g4"],
true,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s:1 a)", intervals: &[] },
],
);
lexer_action_case!(
testlexeractions_test2actionsin1rule_710bd0bd7b,
"testlexeractions-test2actionsin1rule-710bd0bd7b",
&["L.g4"],
"L",
"123 45",
&["[@0,0:2='123',<1>,1:0]", "[@1,4:5='45',<1>,1:4]", "[@2,6:5='<EOF>',<-1>,1:6]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 1, text: "1" },
ExpectedLexerAction { rule: "I", action_index: 1, position: 3, text: "123" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "4" },
ExpectedLexerAction { rule: "I", action_index: 1, position: 6, text: "45" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testactionevalsatcorrectindex_9f940f5340,
"testlexeractions-testactionevalsatcorrectindex-9f940f5340",
&["L.g4"],
"L",
"123 45",
&["[@0,0:2='123',<1>,1:0]", "[@1,4:5='45',<1>,1:4]", "[@2,6:5='<EOF>',<-1>,1:6]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 1, text: "1" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "4" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testactionexecutedindfa_50e2605da3,
"testlexeractions-testactionexecutedindfa-50e2605da3",
&["L.g4"],
"L",
"34 34",
&["[@0,0:1='34',<1>,1:0]", "[@1,3:4='34',<1>,1:3]", "[@2,5:4='<EOF>',<-1>,1:5]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "34" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testactionpluscommand_5f3025038d,
"testlexeractions-testactionpluscommand-5f3025038d",
&["L.g4"],
"L",
"34 34",
&["[@0,5:4='<EOF>',<-1>,1:5]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "34" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testaltactionsin1rule_cd7e8e3c06,
"testlexeractions-testaltactionsin1rule-cd7e8e3c06",
&["L.g4"],
"L",
"123 ab",
&["[@0,0:2='123',<1>,1:0]", "[@1,4:5='ab',<1>,1:4]", "[@2,6:5='<EOF>',<-1>,1:6]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 3, text: "123" },
ExpectedLexerAction { rule: "I", action_index: 2, position: 3, text: "123" },
ExpectedLexerAction { rule: "I", action_index: 1, position: 6, text: "ab" },
ExpectedLexerAction { rule: "I", action_index: 2, position: 6, text: "ab" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testcombinedcommand_7db8eee992,
"testlexeractions-testcombinedcommand-7db8eee992",
&["L.g4"],
"L",
"34#11",
&["[@0,0:1='34',<1>,1:0]", "[@1,2:4='#11',<1>,1:2]", "[@2,5:4='<EOF>',<-1>,1:5]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "#11" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testevalmultipleactions_af7a23955f,
"testlexeractions-testevalmultipleactions-af7a23955f",
&["L.g4"],
"L",
"hello Steve\n",
&["[@0,0:11='hello Steve\\n',<1>,1:0]", "[@1,12:11='<EOF>',<-1>,2:0]"],
&[
ExpectedLexerAction { rule: "HELLO", action_index: 0, position: 6, text: "hello " },
ExpectedLexerAction { rule: "HELLO", action_index: 1, position: 11, text: "hello Steve" },
ExpectedLexerAction { rule: "HELLO", action_index: 2, position: 12, text: "hello Steve\n" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testfailingpredicateevalisnotcached_ccbdf3d728,
"testlexeractions-testfailingpredicateevalisnotcached-ccbdf3d728",
&["TestLexer.g4"],
"TestLexer",
"A line here.\nItem: name of item\nAnother line.\nMore line.\n",
&["[@0,0:12='A line here.\\n',<1>,1:0]", "[@1,13:17='Item:',<2>,2:0]", "[@2,18:30=' name of item',<3>,2:5]", "[@3,31:31='\\n',<4>,2:18]", "[@4,32:45='Another line.\\n',<1>,3:0]", "[@5,46:56='More line.\\n',<1>,4:0]", "[@6,57:56='<EOF>',<-1>,5:0]"],
&[
],
LexerPredicateKind::LineDoesNotStartWithItem,
&[
ExpectedLexerPredicate { rule: "LINE", predicate_index: 0, position: 13, result: true },
ExpectedLexerPredicate { rule: "LINE", predicate_index: 0, position: 32, result: false },
ExpectedLexerPredicate { rule: "LINE", predicate_index: 0, position: 46, result: true },
ExpectedLexerPredicate { rule: "LINE", predicate_index: 0, position: 57, result: true },
],
);
lexer_action_case!(
testlexeractions_testlexermode_f2a59b4427,
"testlexeractions-testlexermode-f2a59b4427",
&["L.g4"],
"L",
"\"abc\" \"ab\"",
&["[@0,0:4='\"abc\"',<2>,1:0]", "[@1,6:9='\"ab\"',<2>,1:6]", "[@2,10:9='<EOF>',<-1>,1:10]"],
&[
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testlexermodeaction_7a42b1be4d,
"testlexeractions-testlexermodeaction-7a42b1be4d",
&["L.g4"],
"L",
"\"abc\" \"ab\"",
&["[@0,0:4='\"abc\"',<2>,1:0]", "[@1,6:9='\"ab\"',<2>,1:6]", "[@2,10:9='<EOF>',<-1>,1:10]"],
&[
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testlexerpushpopmodeaction_680f0b8c72,
"testlexeractions-testlexerpushpopmodeaction-680f0b8c72",
&["L.g4"],
"L",
"\"abc\" \"ab\"",
&["[@0,0:4='\"abc\"',<2>,1:0]", "[@1,6:9='\"ab\"',<2>,1:6]", "[@2,10:9='<EOF>',<-1>,1:10]"],
&[
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testmorecommand_ea46aea2b9,
"testlexeractions-testmorecommand-ea46aea2b9",
&["L.g4"],
"L",
"34#10",
&["[@0,0:1='34',<1>,1:0]", "[@1,2:4='#10',<1>,1:2]", "[@2,5:4='<EOF>',<-1>,1:5]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "#10" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testskipcommand_0be8276f47,
"testlexeractions-testskipcommand-0be8276f47",
&["L.g4"],
"L",
"34 34",
&["[@0,0:1='34',<1>,1:0]", "[@1,3:4='34',<1>,1:3]", "[@2,5:4='<EOF>',<-1>,1:5]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
ExpectedLexerAction { rule: "I", action_index: 0, position: 5, text: "34" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
lexer_action_case!(
testlexeractions_testtypecommand_7d068e482d,
"testlexeractions-testtypecommand-7d068e482d",
&["L.g4"],
"L",
"34#",
&["[@0,0:1='34',<1>,1:0]", "[@1,2:2='#',<2>,1:2]", "[@2,3:2='<EOF>',<-1>,1:3]"],
&[
ExpectedLexerAction { rule: "I", action_index: 0, position: 2, text: "34" },
],
LexerPredicateKind::AlwaysTrue,
&[
],
);
tool_case!(
testparserexec_fail_element_option_5aa5efff9b,
"testparserexec-fail-element-option-5aa5efff9b",
&["T.g4"],
ToolCase::ParserFailOption,
);
tool_case!(
testparserexec_testalternatequotes_39da532222,
"testparserexec-testalternatequotes-39da532222",
&["ModeTagsLexer.g4", "ModeTagsParser.g4"],
ToolCase::ParserAlternateQuotes,
);
tool_case!(
testparserexec_testattributevalueinitialization_65fdb0798a,
"testparserexec-testattributevalueinitialization-65fdb0798a",
&["Data.g4"],
ToolCase::ParserAttributeInitialization,
);
tool_case!(
testparserexec_testcaseinsensitiveincombinedgrammar_6e1c4cb8b9,
"testparserexec-testcaseinsensitiveincombinedgrammar-6e1c4cb8b9",
&["CaseInsensitiveGrammar.g4"],
ToolCase::ParserRuntime { lexer: "CaseInsensitiveGrammarLexer", parser: "CaseInsensitiveGrammarParser", start_rule: "e", input: "NEW Abc (Not a AND not B)" },
);
tool_case!(
testparserexec_testfailedpredicateexceptionstate_3ff3f5083a,
"testparserexec-testfailedpredicateexceptionstate-3ff3f5083a",
&["Psl.g4"],
ToolCase::ParserFailedPredicate,
);
tool_case!(
testparserexec_teststartrulewithouteof_31619be2b5,
"testparserexec-teststartrulewithouteof-31619be2b5",
&["T.g4"],
ToolCase::ParserStartWithoutEof { lexer: "TLexer", parser: "TParser", start_rule: "s", input: "abc 34" },
);
parser_case!(
testparserinterpreter_testa_7e508c6bfe,
"testparserinterpreter-testa-7e508c6bfe",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s a)", intervals: &[IntervalCheck { path: &[], expected: "0..0" }] },
],
);
parser_case!(
testparserinterpreter_testaorb_0b7684146a,
"testparserinterpreter-testaorb-0b7684146a",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s a)", intervals: &[] },
ParserCheck { start_rule: "s", input: "b", tree: "(s b)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testcall_43700bf83b,
"testparserinterpreter-testcall-43700bf83b",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "ac", tree: "(s (t a) c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "bc", tree: "(s (t b) c)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testcall2_9342fd98a3,
"testparserinterpreter-testcall2-9342fd98a3",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "ac", tree: "(s (t (u a)) c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "bc", tree: "(s (t (u b)) c)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testcaseinsensitivetokensinparser_90a37dddef,
"testparserinterpreter-testcaseinsensitivetokensinparser-90a37dddef",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "e", input: "NEW Abc (Not a AND not B)", tree: "(e NEW Abc ( (e (e Not (e a)) AND (e not (e B))) ))", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testemptyfirstrule_a730280ab4,
"testparserinterpreter-testemptyfirstrule-a730280ab4",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s x a)", intervals: &[IntervalCheck { path: &[], expected: "0..0" }, IntervalCheck { path: &[0], expected: "0..-1" }] },
],
);
parser_case!(
testparserinterpreter_testemptyinput_752cd35737,
"testparserinterpreter-testemptyinput-752cd35737",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "", tree: "(s x <EOF>)", intervals: &[IntervalCheck { path: &[], expected: "0..0" }, IntervalCheck { path: &[0], expected: "0..-1" }] },
],
);
parser_case!(
testparserinterpreter_testemptyinputwithcallsafter_f898132ce1,
"testparserinterpreter-testemptyinputwithcallsafter-f898132ce1",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "", tree: "(s (x <EOF>) (y z))", intervals: &[IntervalCheck { path: &[], expected: "0..0" }, IntervalCheck { path: &[0], expected: "0..0" }, IntervalCheck { path: &[1], expected: "0..-1" }] },
],
);
parser_case!(
testparserinterpreter_testemptyruleaftereofinchild_4932ad515d,
"testparserinterpreter-testemptyruleaftereofinchild-4932ad515d",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s (x a <EOF>) y)", intervals: &[IntervalCheck { path: &[], expected: "0..1" }, IntervalCheck { path: &[0], expected: "0..1" }, IntervalCheck { path: &[1], expected: "1..0" }] },
],
);
parser_case!(
testparserinterpreter_testemptyruleafterjusteofinchild_d2d8ab6bbc,
"testparserinterpreter-testemptyruleafterjusteofinchild-d2d8ab6bbc",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "", tree: "(s (x <EOF>) y)", intervals: &[IntervalCheck { path: &[], expected: "0..0" }, IntervalCheck { path: &[0], expected: "0..0" }, IntervalCheck { path: &[1], expected: "0..-1" }] },
],
);
parser_case!(
testparserinterpreter_testemptystartrule_b465816155,
"testparserinterpreter-testemptystartrule-b465816155",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "", tree: "s", intervals: &[] },
ParserCheck { start_rule: "s", input: "a", tree: "s", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testeof_1719f9f799,
"testparserinterpreter-testeof-1719f9f799",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s a <EOF>)", intervals: &[IntervalCheck { path: &[], expected: "0..1" }] },
],
);
parser_case!(
testparserinterpreter_testeofinchild_3b91b85e7e,
"testparserinterpreter-testeofinchild-3b91b85e7e",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s (x a <EOF>))", intervals: &[IntervalCheck { path: &[], expected: "0..1" }, IntervalCheck { path: &[0], expected: "0..1" }] },
],
);
parser_case!(
testparserinterpreter_testleftrecursion_c0160bad5b,
"testparserinterpreter-testleftrecursion-c0160bad5b",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "a", tree: "(s (e a))", intervals: &[] },
ParserCheck { start_rule: "s", input: "a+a", tree: "(s (e (e a) + (e a)))", intervals: &[] },
ParserCheck { start_rule: "s", input: "a*a", tree: "(s (e (e a) * (e a)))", intervals: &[] },
ParserCheck { start_rule: "s", input: "a+a+a", tree: "(s (e (e (e a) + (e a)) + (e a)))", intervals: &[] },
ParserCheck { start_rule: "s", input: "a*a+a", tree: "(s (e (e (e a) * (e a)) + (e a)))", intervals: &[] },
ParserCheck { start_rule: "s", input: "a+a*a", tree: "(s (e (e a) + (e (e a) * (e a))))", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testleftrecursivestartrule_707842eb76,
"testparserinterpreter-testleftrecursivestartrule-707842eb76",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "e", input: "a", tree: "(e a)", intervals: &[] },
ParserCheck { start_rule: "e", input: "a+a", tree: "(e (e a) + (e a))", intervals: &[] },
ParserCheck { start_rule: "e", input: "a*a", tree: "(e (e a) * (e a))", intervals: &[] },
ParserCheck { start_rule: "e", input: "a+a+a", tree: "(e (e (e a) + (e a)) + (e a))", intervals: &[] },
ParserCheck { start_rule: "e", input: "a*a+a", tree: "(e (e (e a) * (e a)) + (e a))", intervals: &[] },
ParserCheck { start_rule: "e", input: "a+a*a", tree: "(e (e a) + (e (e a) * (e a)))", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testoptionala_944b52f7df,
"testparserinterpreter-testoptionala-944b52f7df",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "b", tree: "(s b)", intervals: &[] },
ParserCheck { start_rule: "s", input: "ab", tree: "(s a b)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_testoptionalaorb_489d46e116,
"testparserinterpreter-testoptionalaorb-489d46e116",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "c", tree: "(s c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "ac", tree: "(s a c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "bc", tree: "(s b c)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_teststara_fbfd9832c6,
"testparserinterpreter-teststara-fbfd9832c6",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "b", tree: "(s b)", intervals: &[] },
ParserCheck { start_rule: "s", input: "ab", tree: "(s a b)", intervals: &[] },
ParserCheck { start_rule: "s", input: "aaaaaab", tree: "(s a a a a a a b)", intervals: &[] },
],
);
parser_case!(
testparserinterpreter_teststaraorb_0dc25899c2,
"testparserinterpreter-teststaraorb-0dc25899c2",
&["L.g4", "T.g4"],
false,
&[
ParserCheck { start_rule: "s", input: "c", tree: "(s c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "ac", tree: "(s a c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "bc", tree: "(s b c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "abaaabc", tree: "(s a b a a a b c)", intervals: &[] },
ParserCheck { start_rule: "s", input: "babac", tree: "(s b a b a c)", intervals: &[] },
],
);