// Generated by tools/grammar-frontend/generate-phase-c-runtime-fixtures.mjs.
// Inputs and behavior oracles come from pinned Java ANTLR 4.13.2 cases.

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: &[] },
    ],
);
