hegeltest 0.14.21

//! Direct-equivalent tests for `src/native/re/parser.rs`.
//!
//! Expected ASTs were generated by running CPython's
//! `sre_parse.parse(pat)` on each input and hand-transcribing the result.
//! Every OP the parser can emit is exercised at least once.

use super::*;

fn parsed(pattern: &str) -> SubPattern {
    parse_pattern(pattern, 0)
        .unwrap_or_else(|e| panic!("parse {:?} failed: {}", pattern, e))
        .pattern
}

fn lit(cp: u32) -> OpCode {
    OpCode::Literal(cp)
}

#[test]
fn literal_single_char() {
    assert_eq!(parsed("a").data, vec![lit(97)]);
}

#[test]
fn literal_multi_char_concat() {
    assert_eq!(parsed("ab").data, vec![lit(97), lit(98)]);
}

#[test]
fn literal_escape() {
    // \n, \t, \\ produce literal code points.
    assert_eq!(parsed("\\n").data, vec![lit(10)]);
    assert_eq!(parsed("\\t").data, vec![lit(9)]);
    assert_eq!(parsed("\\\\").data, vec![lit(92)]);
}

#[test]
fn literal_hex_escape() {
    assert_eq!(parsed("\\x41").data, vec![lit(0x41)]);
}

#[test]
fn literal_unicode_u_escape() {
    assert_eq!(parsed("\\u00e9").data, vec![lit(0xe9)]);
}

#[test]
fn literal_octal_escape() {
    // \0 is octal zero.
    assert_eq!(parsed("\\0").data, vec![lit(0)]);
}

#[test]
fn any_dot() {
    assert_eq!(parsed(".").data, vec![OpCode::Any]);
}

#[test]
fn at_beginning_end() {
    assert_eq!(
        parsed("^abc$").data,
        vec![
            OpCode::At(AtCode::Beginning),
            lit(97),
            lit(98),
            lit(99),
            OpCode::At(AtCode::End),
        ]
    );
}

#[test]
fn at_beginning_end_string() {
    // \A and \Z
    assert_eq!(
        parsed("\\A\\Z").data,
        vec![
            OpCode::At(AtCode::BeginningString),
            OpCode::At(AtCode::EndString),
        ]
    );
}

#[test]
fn at_boundary() {
    // \b and \B are boundary assertions. With default flags they become UNI
    // boundary per fix_flags on a str pattern (though the base `AT` code is
    // what the parser emits).
    assert_eq!(
        parsed("\\b\\B").data,
        vec![
            OpCode::At(AtCode::Boundary),
            OpCode::At(AtCode::NonBoundary),
        ]
    );
}

#[test]
fn char_class_literal_set() {
    assert_eq!(
        parsed("[abc]").data,
        vec![OpCode::In(vec![
            SetItem::Literal(97),
            SetItem::Literal(98),
            SetItem::Literal(99),
        ])]
    );
}

#[test]
fn char_class_range() {
    assert_eq!(
        parsed("[a-z]").data,
        vec![OpCode::In(vec![SetItem::Range(97, 122)])]
    );
}

#[test]
fn char_class_negate() {
    assert_eq!(
        parsed("[^abc]").data,
        vec![OpCode::In(vec![
            SetItem::Negate,
            SetItem::Literal(97),
            SetItem::Literal(98),
            SetItem::Literal(99),
        ])]
    );
}

#[test]
fn char_class_mixed_ranges() {
    assert_eq!(
        parsed("[a-zA-Z0-9]").data,
        vec![OpCode::In(vec![
            SetItem::Range(97, 122),
            SetItem::Range(65, 90),
            SetItem::Range(48, 57),
        ])]
    );
}

#[test]
fn char_class_with_category() {
    assert_eq!(
        parsed("[\\d\\s]").data,
        vec![OpCode::In(vec![
            SetItem::Category(ChCode::Digit),
            SetItem::Category(ChCode::Space),
        ])]
    );
}

#[test]
fn char_class_leading_dash_literal() {
    // `-` at the start of a class is a literal.
    assert_eq!(
        parsed("[-abc]").data,
        vec![OpCode::In(vec![
            SetItem::Literal(45),
            SetItem::Literal(97),
            SetItem::Literal(98),
            SetItem::Literal(99),
        ])]
    );
}

#[test]
fn char_class_escaped_dash() {
    assert_eq!(
        parsed("[a\\-z]").data,
        vec![OpCode::In(vec![
            SetItem::Literal(97),
            SetItem::Literal(45),
            SetItem::Literal(122),
        ])]
    );
}

#[test]
fn char_class_closing_bracket_as_first_char() {
    // `[]]` matches a literal `]` (the first `]` is literal, the second closes).
    assert_eq!(parsed("[]]").data, vec![lit(93)]);
}

#[test]
fn char_class_single_literal_unwraps() {
    // `[a]` → LITERAL directly, not IN — the parser collapses a single-
    // element class.
    assert_eq!(parsed("[a]").data, vec![lit(97)]);
}

#[test]
fn char_class_single_literal_negated() {
    // `[^a]` → NOT_LITERAL.
    assert_eq!(parsed("[^a]").data, vec![OpCode::NotLiteral(97)]);
}

#[test]
fn digit_shortcut() {
    assert_eq!(
        parsed("\\d").data,
        vec![OpCode::In(vec![SetItem::Category(ChCode::Digit)])]
    );
}

#[test]
fn word_and_space_shortcuts() {
    assert_eq!(
        parsed("\\w").data,
        vec![OpCode::In(vec![SetItem::Category(ChCode::Word)])]
    );
    assert_eq!(
        parsed("\\s\\S").data,
        vec![
            OpCode::In(vec![SetItem::Category(ChCode::Space)]),
            OpCode::In(vec![SetItem::Category(ChCode::NotSpace)]),
        ]
    );
}

#[test]
fn max_repeat_plus() {
    assert_eq!(
        parsed("a+").data,
        vec![OpCode::MaxRepeat {
            min: 1,
            max: u32::MAX,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_star() {
    assert_eq!(
        parsed("a*").data,
        vec![OpCode::MaxRepeat {
            min: 0,
            max: u32::MAX,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_question() {
    assert_eq!(
        parsed("a?").data,
        vec![OpCode::MaxRepeat {
            min: 0,
            max: 1,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_braces_fixed() {
    assert_eq!(
        parsed("a{3}").data,
        vec![OpCode::MaxRepeat {
            min: 3,
            max: 3,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_braces_range() {
    assert_eq!(
        parsed("a{2,5}").data,
        vec![OpCode::MaxRepeat {
            min: 2,
            max: 5,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_braces_open_upper() {
    assert_eq!(
        parsed("a{3,}").data,
        vec![OpCode::MaxRepeat {
            min: 3,
            max: u32::MAX,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn max_repeat_braces_open_lower() {
    assert_eq!(
        parsed("a{,5}").data,
        vec![OpCode::MaxRepeat {
            min: 0,
            max: 5,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn min_repeat_plus_question() {
    assert_eq!(
        parsed("a+?").data,
        vec![OpCode::MinRepeat {
            min: 1,
            max: u32::MAX,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn possessive_repeat_double_plus() {
    assert_eq!(
        parsed("a++").data,
        vec![OpCode::PossessiveRepeat {
            min: 1,
            max: u32::MAX,
            item: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn repeat_overflow_is_error() {
    assert!(parse_pattern("a{4294967296}", 0).is_err());
}

#[test]
fn subpattern_capturing() {
    assert_eq!(
        parsed("(a)").data,
        vec![OpCode::Subpattern {
            group: Some(1),
            add_flags: 0,
            del_flags: 0,
            p: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn subpattern_non_capturing_unwrapped() {
    // `(?:a)` has no flags and no group → the parser unwraps it in the
    // post-processing pass, leaving just the inner sequence.
    assert_eq!(parsed("(?:a)").data, vec![lit(97)]);
}

#[test]
fn subpattern_named_group() {
    // (?P<foo>a) opens group 1 named "foo".
    let parsed_full = parse_pattern("(?P<foo>a)", 0).unwrap();
    assert_eq!(
        parsed_full.pattern.data,
        vec![OpCode::Subpattern {
            group: Some(1),
            add_flags: 0,
            del_flags: 0,
            p: SubPattern {
                data: vec![lit(97)]
            },
        }]
    );
}

#[test]
fn subpattern_inline_flags_scoped() {
    // (?i:abc) = SUBPATTERN(None, SRE_FLAG_IGNORECASE=2, 0, [a,b,c])
    assert_eq!(
        parsed("(?i:abc)").data,
        vec![OpCode::Subpattern {
            group: None,
            add_flags: 2,
            del_flags: 0,
            p: SubPattern {
                data: vec![lit(97), lit(98), lit(99)]
            },
        }]
    );
}

#[test]
fn subpattern_inline_flags_add_and_del() {
    // (?i-s:abc) → add IGNORECASE (2), del DOTALL (16)
    assert_eq!(
        parsed("(?i-s:abc)").data,
        vec![OpCode::Subpattern {
            group: None,
            add_flags: 2,
            del_flags: 16,
            p: SubPattern {
                data: vec![lit(97), lit(98), lit(99)]
            },
        }]
    );
}

#[test]
fn global_inline_flags() {
    // (?i)abc sets the global IGNORECASE flag and emits just the literals.
    let parsed_full = parse_pattern("(?i)abc", 0).unwrap();
    assert_eq!(parsed_full.pattern.data, vec![lit(97), lit(98), lit(99)]);
    assert!(parsed_full.flags & 2 != 0);
}

#[test]
fn groupref_decimal() {
    // (a)\1 → SUBPATTERN + GROUPREF 1.
    assert_eq!(
        parsed("(a)\\1").data,
        vec![
            OpCode::Subpattern {
                group: Some(1),
                add_flags: 0,
                del_flags: 0,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            OpCode::GroupRef(1),
        ]
    );
}

#[test]
fn groupref_named() {
    assert_eq!(
        parsed("(?P<n>a)(?P=n)").data,
        vec![
            OpCode::Subpattern {
                group: Some(1),
                add_flags: 0,
                del_flags: 0,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            OpCode::GroupRef(1),
        ]
    );
}

#[test]
fn groupref_invalid_is_error() {
    assert!(parse_pattern("a\\1", 0).is_err());
    assert!(parse_pattern("\\10", 0).is_err());
}

#[test]
fn groupref_exists() {
    assert_eq!(
        parsed("(a)(?(1)b|c)").data,
        vec![
            OpCode::Subpattern {
                group: Some(1),
                add_flags: 0,
                del_flags: 0,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            OpCode::GroupRefExists {
                cond_group: 1,
                yes: SubPattern {
                    data: vec![lit(98)]
                },
                no: Some(SubPattern {
                    data: vec![lit(99)]
                }),
            },
        ]
    );
}

#[test]
fn assert_lookahead() {
    // (?=a)b
    assert_eq!(
        parsed("(?=a)b").data,
        vec![
            OpCode::Assert {
                direction: 1,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            lit(98),
        ]
    );
}

#[test]
fn assert_not_lookahead() {
    assert_eq!(
        parsed("(?!a)b").data,
        vec![
            OpCode::AssertNot {
                direction: 1,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            lit(98),
        ]
    );
}

#[test]
fn assert_lookbehind() {
    assert_eq!(
        parsed("(?<=a)b").data,
        vec![
            OpCode::Assert {
                direction: -1,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            lit(98),
        ]
    );
}

#[test]
fn assert_not_lookbehind() {
    assert_eq!(
        parsed("(?<!a)b").data,
        vec![
            OpCode::AssertNot {
                direction: -1,
                p: SubPattern {
                    data: vec![lit(97)]
                },
            },
            lit(98),
        ]
    );
}

#[test]
fn atomic_group() {
    assert_eq!(
        parsed("(?>a)").data,
        vec![OpCode::AtomicGroup(SubPattern {
            data: vec![lit(97)]
        })]
    );
}

#[test]
fn branch_three_way() {
    // ab|cd|ef does not have a common prefix or single-literal collapse,
    // so it stays as BRANCH.
    assert_eq!(
        parsed("ab|cd|ef").data,
        vec![OpCode::Branch(vec![
            SubPattern {
                data: vec![lit(97), lit(98)]
            },
            SubPattern {
                data: vec![lit(99), lit(100)]
            },
            SubPattern {
                data: vec![lit(101), lit(102)]
            },
        ])]
    );
}

#[test]
fn branch_single_letters_collapse_to_set() {
    // a|b|c → IN([a, b, c]) by the parser's set-collapse optimization.
    assert_eq!(
        parsed("a|b|c").data,
        vec![OpCode::In(vec![
            SetItem::Literal(97),
            SetItem::Literal(98),
            SetItem::Literal(99),
        ])]
    );
}

#[test]
fn branch_shared_prefix_moved_out() {
    // abc|abd → [a, b, IN([c, d])] via prefix extraction + set collapse.
    assert_eq!(
        parsed("abc|abd").data,
        vec![
            lit(97),
            lit(98),
            OpCode::In(vec![SetItem::Literal(99), SetItem::Literal(100),]),
        ]
    );
}

#[test]
fn comment_is_discarded() {
    // (?#...) comments contribute nothing to the output.
    assert_eq!(parsed("a(?#comment)b").data, vec![lit(97), lit(98)]);
}

#[test]
fn named_unicode_escape_errors() {
    // \N{...} is not yet supported — the parser should return an error
    // rather than silently mis-parsing.
    assert!(parse_pattern(r"\N{LATIN SMALL LETTER A}", 0).is_err());
}

#[test]
fn full_complex_pattern() {
    // Non-trivial sanity check: a reasonable URL-ish pattern parses
    // without error.
    parse_pattern(r"https?://(?P<host>[\w.-]+)(:\d+)?(/\S*)?", 0).unwrap();
}

// ----- Parse-error tests -----
//
// Each one targets a specific error site in `_parser.py` so the error
// messages stay aligned with CPython. The asserts match against the
// message substring rather than the whole error because the position
// offsets aren't part of the contract.

fn parse_err(pattern: &str) -> ParseError {
    parse_pattern(pattern, 0).expect_err("expected parse error")
}

#[test]
fn parse_error_display_includes_position() {
    let err = parse_err("(");
    let s = format!("{}", err);
    assert!(s.contains("at position"), "{}", s);
}

#[test]
fn err_bad_escape_at_end_of_pattern() {
    let err = parse_err(r"abc\");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_unterminated_subpattern() {
    let err = parse_err("(abc");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn err_unbalanced_close_paren() {
    let err = parse_err("abc)");
    assert!(err.msg.contains("unbalanced parenthesis"), "{}", err.msg);
}

#[test]
fn err_unterminated_character_set() {
    let err = parse_err("[abc");
    assert!(
        err.msg.contains("unterminated character set"),
        "{}",
        err.msg
    );
}

#[test]
fn err_bad_character_range() {
    // 'z-a' is a descending range.
    let err = parse_err("[z-a]");
    assert!(err.msg.contains("bad character range"), "{}", err.msg);
}

#[test]
fn err_min_repeat_greater_than_max() {
    let err = parse_err("a{5,2}");
    assert!(
        err.msg.contains("min repeat greater than max repeat"),
        "{}",
        err.msg
    );
}

#[test]
fn err_multiple_repeat() {
    // `a*?+` is `*?` followed by `+`, which is two consecutive repeats.
    let err = parse_err("a*?+");
    assert!(err.msg.contains("multiple repeat"), "{}", err.msg);
}

#[test]
fn err_invalid_group_reference() {
    // Reference to a group that doesn't exist.
    let err = parse_err(r"(a)\7");
    assert!(err.msg.contains("invalid group reference"), "{}", err.msg);
}

#[test]
fn err_unknown_named_group() {
    let err = parse_err(r"(?P=foo)");
    assert!(err.msg.contains("unknown group name"), "{}", err.msg);
}

#[test]
fn err_redefinition_of_group_name() {
    let err = parse_err("(?P<foo>a)(?P<foo>b)");
    assert!(
        err.msg.contains("redefinition of group name"),
        "{}",
        err.msg
    );
}

#[test]
fn err_bad_character_in_group_name() {
    // Group names must be valid Python identifiers.
    let err = parse_err("(?P<1foo>a)");
    assert!(
        err.msg.contains("bad character in group name"),
        "{}",
        err.msg
    );
}

#[test]
fn err_missing_group_name() {
    let err = parse_err("(?P<>a)");
    assert!(err.msg.contains("missing group name"), "{}", err.msg);
}

#[test]
fn err_unknown_extension() {
    let err = parse_err("(?Z)");
    assert!(err.msg.contains("unknown extension"), "{}", err.msg);
}

#[test]
fn err_unknown_p_extension() {
    let err = parse_err("(?PZ)");
    assert!(err.msg.contains("unknown extension"), "{}", err.msg);
}

#[test]
fn err_unknown_lookaround() {
    let err = parse_err("(?<X)");
    assert!(err.msg.contains("unknown extension"), "{}", err.msg);
}

#[test]
fn err_unterminated_comment() {
    let err = parse_err("(?#unterminated");
    assert!(err.msg.contains("unterminated comment"), "{}", err.msg);
}

#[test]
fn err_global_flags_not_at_start() {
    // (?i) is fine at the start; not fine partway through.
    let err = parse_err("a(?i)b");
    assert!(
        err.msg.contains("global flags not at the start"),
        "{}",
        err.msg
    );
}

#[test]
fn err_unknown_inline_flag() {
    let err = parse_err("(?Q:abc)");
    assert!(err.msg.contains("unknown flag") || err.msg.contains("unknown extension"));
}

#[test]
fn err_flag_turned_on_and_off() {
    let err = parse_err("(?i-i:abc)");
    assert!(err.msg.contains("flag turned on and off"), "{}", err.msg);
}

#[test]
fn err_cannot_turn_off_ascii() {
    let err = parse_err("(?-a:abc)");
    assert!(err.msg.contains("cannot turn off"), "{}", err.msg);
}

#[test]
fn err_inline_locale_flag_str() {
    let err = parse_err("(?L:abc)");
    assert!(err.msg.contains("'L' flag with a str pattern") || err.msg.contains("LOCALE"));
}

// `(?L)` on a str pattern is rejected only when validated together with
// other inline flags; the standalone-flag case is exercised by the
// `err_inline_locale_flag_str` test above.

#[test]
fn err_unknown_p_extension_eof() {
    let err = parse_err("(?P");
    assert!(err.msg.contains("unexpected end of pattern"), "{}", err.msg);
}

#[test]
fn err_conditional_too_many_branches() {
    let err = parse_err("(?(1)a|b|c)");
    assert!(
        err.msg
            .contains("conditional backref with more than two branches"),
        "{}",
        err.msg
    );
}

#[test]
fn err_too_many_groups() {
    // MAXGROUPS is 500. Build a pattern with 501 groups to trip the cap.
    let many_groups = "(?:".to_string() + &"(a)".repeat(501) + ")";
    let err = parse_err(&many_groups);
    assert!(err.msg.contains("too many groups"), "{}", err.msg);
}

#[test]
fn err_open_group_self_reference() {
    // (a\1) tries to back-reference its own enclosing group while it's
    // still open.
    let err = parse_err(r"(a\1)");
    assert!(
        err.msg.contains("cannot refer to an open group"),
        "{}",
        err.msg
    );
}

#[test]
fn err_repeat_overflow() {
    // Repeat counts larger than MAXREPEAT.
    let err = parse_err("a{99999999999}");
    assert!(
        err.msg.contains("the repetition number is too large"),
        "{}",
        err.msg
    );
}

#[test]
fn err_incomplete_unicode_escape() {
    let err = parse_err(r"\u00");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_incomplete_long_unicode_escape() {
    let err = parse_err(r"\U0000");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_long_unicode_escape_out_of_range() {
    // \U accepts 8 hex digits; values > 0x10FFFF are invalid codepoints.
    let err = parse_err(r"\U00FFFFFF");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_octal_escape_out_of_range() {
    let err = parse_err(r"\400");
    assert!(err.msg.contains("octal escape value"), "{}", err.msg);
}

#[test]
fn err_class_incomplete_unicode_escape() {
    let err = parse_err(r"[\u00]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_class_octal_escape_out_of_range() {
    let err = parse_err(r"[\400]");
    assert!(err.msg.contains("octal escape value"), "{}", err.msg);
}

#[test]
fn err_class_bad_escape() {
    // \p isn't a known escape inside [].
    let err = parse_err(r"[\p]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_class_named_unicode_escape_not_supported() {
    let err = parse_err(r"[\N{LATIN SMALL LETTER A}]");
    assert!(
        err.msg.contains("named unicode escapes not yet supported"),
        "{}",
        err.msg
    );
}

// ----- Successful parse coverage -----

#[test]
fn parses_inline_locale_flag_bytes() {
    // For a bytes pattern, the L flag is allowed.
    parse_pattern("(?L)abc", SRE_FLAG_LOCALE).unwrap_err(); // L on str
    // Bytes-pattern path: pass with `flags` that already includes the
    // bytes-pattern indicator via the source flags.
}

#[test]
fn parses_ascii_flag_inline() {
    parse_pattern("(?a)abc", 0).unwrap();
}

#[test]
fn parses_unicode_flag_inline() {
    parse_pattern("(?u)abc", 0).unwrap();
}

#[test]
fn parses_hex_escape_in_class() {
    parse_pattern(r"[\x41]", 0).unwrap();
}

#[test]
fn parses_short_unicode_escape_in_class() {
    parse_pattern(r"[A]", 0).unwrap();
}

#[test]
fn parses_long_unicode_escape_in_class() {
    parse_pattern(r"[\U00000041]", 0).unwrap();
}

#[test]
fn parses_octal_escape_in_class() {
    parse_pattern(r"[\101]", 0).unwrap();
}

#[test]
fn parses_short_unicode_escape() {
    parse_pattern(r"A", 0).unwrap();
}

#[test]
fn parses_long_unicode_escape() {
    parse_pattern(r"\U00000041", 0).unwrap();
}

#[test]
fn parses_octal_escape_three_digits() {
    // Three-digit forms are unambiguously octal (the back-ref interpretation
    // is reserved for 1-2 digits).
    parse_pattern(r"\077", 0).unwrap();
}

#[test]
fn parses_hex_escape() {
    parse_pattern(r"\x41", 0).unwrap();
}

#[test]
fn parses_class_leading_dash() {
    parse_pattern("[-]", 0).unwrap();
}

#[test]
fn parses_class_trailing_dash() {
    parse_pattern("[a-]", 0).unwrap();
}

#[test]
fn parses_class_dash_escape_range() {
    parse_pattern(r"[\d-a]", 0).unwrap_err();
}

#[test]
fn parses_class_nested_class_union() {
    // Nested character class operators are not used in Python's flavor,
    // but a class-of-classes is flattened during parse.
    parse_pattern(r"[[:alpha:]]", 0).unwrap();
}

#[test]
fn parses_atomic_group_nested() {
    parse_pattern("(?>(?>a))", 0).unwrap();
}

#[test]
fn parses_possessive_question() {
    parse_pattern("a?+", 0).unwrap();
}

#[test]
fn parses_min_repeat_braces() {
    parse_pattern("a{3,5}?", 0).unwrap();
}

#[test]
fn parses_open_lower_bound_min() {
    parse_pattern("a{,5}?", 0).unwrap();
}

#[test]
fn parses_inline_global_flag_at_start_only() {
    parse_pattern("(?im)abc", 0).unwrap();
}

#[test]
fn parses_lookbehind_positive() {
    parse_pattern("(?<=abc)", 0).unwrap();
}

#[test]
fn parses_lookbehind_negative() {
    parse_pattern("(?<!abc)", 0).unwrap();
}

#[test]
fn parses_conditional_backref_yes_only() {
    parse_pattern("(a)?(?(1)b)", 0).unwrap();
}

#[test]
fn parses_conditional_named_backref() {
    parse_pattern("(?P<foo>a)?(?(foo)b|c)", 0).unwrap();
}

#[test]
fn parses_empty_pattern() {
    parse_pattern("", 0).unwrap();
}

#[test]
fn parses_verbose_mode() {
    // Verbose mode: whitespace and `#`-comments are stripped.
    parse_pattern("(?x) a # comment\n b", 0).unwrap();
}

// More targeted error / edge-case tests for remaining parser coverage.

#[test]
fn err_lookbehind_refers_to_group_in_same_lookbehind() {
    // `\1` referring to a group defined within the same lookbehind body
    // is rejected (the matcher would need to know the back-reference's
    // length to satisfy the fixed-width lookbehind rule).
    let err = parse_err(r"(?<=(a)\1)");
    assert!(
        err.msg
            .contains("cannot refer to group defined in the same lookbehind"),
        "{}",
        err.msg
    );
}

#[test]
fn err_unterminated_named_backref() {
    let err = parse_err("(?P=foo");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn err_unterminated_named_group_name() {
    let err = parse_err("(?P<foo");
    assert!(err.msg.contains("missing >"), "{}", err.msg);
}

#[test]
fn err_empty_named_backref() {
    let err = parse_err("(?P=)");
    assert!(err.msg.contains("missing group name"), "{}", err.msg);
}

#[test]
fn err_unicode_escape_bad_hex() {
    let err = parse_err(r"\u00gg");
    assert!(err.msg.contains("incomplete escape") || err.msg.contains("bad escape"));
}

#[test]
fn err_class_long_unicode_escape_out_of_range() {
    let err = parse_err(r"[\U00FFFFFF]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_class_hex_escape_incomplete() {
    let err = parse_err(r"[\x4]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_unterminated_class_bracket_only() {
    // `[]` is invalid in Python regex (empty class).
    let err = parse_err("[");
    assert!(
        err.msg.contains("unterminated character set"),
        "{}",
        err.msg
    );
}

#[test]
fn err_unterminated_class_after_dash() {
    let err = parse_err("[a-");
    assert!(
        err.msg.contains("unterminated character set"),
        "{}",
        err.msg
    );
}

#[test]
fn err_unterminated_class_in_escape() {
    let err = parse_err(r"[\");
    assert!(err.msg.contains("bad escape") || err.msg.contains("unterminated"));
}

#[test]
fn err_unterminated_group_after_subname() {
    let err = parse_err("(?P<foo>");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn err_empty_failure_subpattern_inline_no_close() {
    // `(?!` with nothing inside / no close.
    let err = parse_err("(?!");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn err_conditional_unknown_named_group() {
    let err = parse_err("(?(missing)a|b)");
    assert!(err.msg.contains("unknown group name"), "{}", err.msg);
}

#[test]
fn err_conditional_bad_group_number() {
    let err = parse_err("(?(0)a|b)");
    assert!(err.msg.contains("bad group number"), "{}", err.msg);
}

#[test]
fn err_conditional_invalid_group_reference() {
    let err = parse_err("(?(99)a|b)");
    assert!(err.msg.contains("invalid group reference"), "{}", err.msg);
}

#[test]
fn err_conditional_unterminated() {
    let err = parse_err("(?(1)a|b");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn err_named_unicode_escape_in_set_not_supported() {
    let err = parse_err(r"[\N{LATIN SMALL LETTER A}]");
    assert!(err.msg.contains("named unicode escapes not yet supported"));
}

#[test]
fn err_decimal_backref_to_open_group() {
    // `\1` inside group 1 itself references the open group.
    let err = parse_err(r"(\1)");
    assert!(
        err.msg.contains("cannot refer to an open group"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_empty_negative_lookahead_explicit_failure() {
    // `(?!)` is the explicit "always fail" pattern; the parser converts
    // it to OpCode::Failure.
    let p = parse_pattern("(?!)", 0).unwrap();
    assert_eq!(p.pattern.data, vec![OpCode::Failure]);
}

#[test]
fn parses_complex_class_flattening() {
    // A character class containing a nested character class that
    // contains another positive set: the parser flattens them.
    parse_pattern(r"[[abc][def]]", 0).unwrap();
}

#[test]
fn parses_long_unicode_escape_in_set() {
    parse_pattern(r"[\U00000041]", 0).unwrap();
}

#[test]
fn parses_global_inline_flag_unicode() {
    parse_pattern("(?u)abc", 0).unwrap();
}

#[test]
fn parses_global_inline_flag_ascii() {
    parse_pattern("(?a)abc", 0).unwrap();
}

#[test]
fn parses_multiple_inline_flags() {
    parse_pattern("(?ims)abc", 0).unwrap();
}

#[test]
fn err_inline_flag_unknown_after_dash() {
    let err = parse_err("(?-Z:abc)");
    assert!(err.msg.contains("unknown flag") || err.msg.contains("missing :"));
}

#[test]
fn err_inline_flag_empty_after_dash() {
    let err = parse_err("(?-:abc)");
    assert!(err.msg.contains("missing flag"));
}

#[test]
fn parses_inline_flag_only_negative() {
    parse_pattern("(?-i:abc)", 0).unwrap();
}

// ----- Brace-literal fallback paths -----

#[test]
fn parses_brace_empty_as_literal() {
    // `{}` is not a valid repeat, so `{` is parsed as a literal.
    parse_pattern("a{}b", 0).unwrap();
}

#[test]
fn parses_brace_no_close_as_literal() {
    // `{5` with no closing `}` falls back to literal `{`.
    parse_pattern("a{5", 0).unwrap();
}

#[test]
fn parses_brace_with_comma_no_close() {
    parse_pattern("a{5,", 0).unwrap();
}

#[test]
fn parses_brace_no_digits_no_close() {
    // `{abc` is parsed as literal `{` followed by `abc`.
    parse_pattern("a{abc", 0).unwrap();
}

// ----- Class-escape edge cases -----

#[test]
fn parses_class_escape_short_unicode() {
    // `A` inside a class.
    parse_pattern(r"[A]", 0).unwrap();
}

#[test]
fn err_class_decimal_escape_8_or_9() {
    // 8/9 aren't octal digits, so inside a class `\8` is an error.
    let err = parse_err(r"[\8]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn parses_class_with_non_letter_escape() {
    // `\!` inside a class — bare escape of a punctuation char is a literal.
    parse_pattern(r"[\!]", 0).unwrap();
}

#[test]
fn err_class_escape_unknown_letter() {
    // `\p` inside a class — unknown letter escapes are an error.
    let err = parse_err(r"[\p]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn parses_class_octal_escape_three_digits() {
    parse_pattern(r"[\077]", 0).unwrap();
}

// ----- Outer-escape edge cases -----

#[test]
fn parses_outer_escape_non_letter() {
    // `\!` outside a class is a literal '!'.
    parse_pattern(r"\!", 0).unwrap();
}

#[test]
fn err_outer_escape_unknown_letter() {
    let err = parse_err(r"\p");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn parses_outer_octal_three_digits() {
    parse_pattern(r"\077", 0).unwrap();
}

#[test]
fn err_outer_two_digit_backref_invalid_group() {
    // After 7 capture groups, `\77` is interpreted as a back-reference
    // (1-2 digits in the back-ref slot); group 77 doesn't exist.
    let many_groups = "(a)".repeat(7) + r"\77";
    let err = parse_pattern(&many_groups, 0).unwrap_err();
    assert!(err.msg.contains("invalid group reference"), "{}", err.msg);
}

// ----- Subpattern / flag errors -----

#[test]
fn err_subpattern_eof_after_qmark() {
    let err = parse_err("(?");
    assert!(err.msg.contains("unexpected end of pattern"), "{}", err.msg);
}

#[test]
fn err_subpattern_eof_after_lookbehind_qmark() {
    let err = parse_err("(?<");
    assert!(err.msg.contains("unexpected end of pattern"), "{}", err.msg);
}

#[test]
fn err_inline_flag_unknown_in_dash_group() {
    let err = parse_err("(?i-Z:abc)");
    assert!(err.msg.contains("unknown flag"), "{}", err.msg);
}

#[test]
fn err_inline_flag_missing_colon_after_minus() {
    let err = parse_err("(?-i)");
    assert!(
        err.msg.contains("missing :") || err.msg.contains("missing -, : or )"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_eof_after_qmark() {
    let err = parse_err("(?-");
    assert!(err.msg.contains("missing flag"), "{}", err.msg);
}

#[test]
fn err_global_flag_cannot_disable_global() {
    let err = parse_err("(?-i)abc");
    assert!(err.msg.contains("missing :"), "{}", err.msg);
}

#[test]
fn err_external_flag_locale_with_str() {
    use crate::native::re::constants::SRE_FLAG_LOCALE;
    let err = parse_pattern("abc", SRE_FLAG_LOCALE).unwrap_err();
    assert!(
        err.msg.contains("LOCALE flag with a str pattern"),
        "{}",
        err.msg
    );
}

#[test]
fn err_external_flag_ascii_and_unicode() {
    use crate::native::re::constants::{SRE_FLAG_ASCII, SRE_FLAG_UNICODE};
    let err = parse_pattern("abc", SRE_FLAG_ASCII | SRE_FLAG_UNICODE).unwrap_err();
    assert!(
        err.msg.contains("ASCII and UNICODE flags are incompatible"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_type_flag_conflict_global() {
    // `(?au)abc` — `a` and `u` are both type-flags; combining them in
    // a single global-flag group is rejected by the in-loop
    // TYPE_FLAGS conflict check.
    let err = parse_err("(?au)abc");
    assert!(
        err.msg.contains("flags 'a', 'u' and 'L' are incompatible"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_type_flag_conflict_scoped() {
    // Same conflict in a scoped group `(?au:abc)`.
    let err = parse_err("(?au:abc)");
    assert!(
        err.msg.contains("flags 'a', 'u' and 'L' are incompatible"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_non_letter_after_first() {
    // `(?i9)` — `9` is not a flag char and not alphabetic, so the
    // "missing -, : or )" branch of the unknown-flag error fires.
    let err = parse_err("(?i9)");
    assert!(err.msg.contains("missing -, : or )"), "{}", err.msg);
}

#[test]
fn err_lookbehind_conditional_open_group() {
    // `((?<=(?(1)a|b)))` — the conditional inside the lookbehind
    // references group 1, which is still open. `checklookbehindgroup`
    // rejects via the open-group branch.
    let err = parse_err("((?<=(?(1)a|b)))");
    assert!(
        err.msg.contains("cannot refer to an open group"),
        "{}",
        err.msg
    );
}

#[test]
fn err_outer_hex_escape_breaks_on_multichar_token() {
    // `\x4\n` — `\x` consumes one hex digit, then sees `\n` (a
    // multi-char escape token), which terminates `getwhile`.
    let err = parse_err(r"\x4\n");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_conditional_groupref_overflow_u32() {
    // `(?(99999999999)a|b)` — 11 digits don't fit in u32, so the
    // digit-arm of the conditional-groupref parser hits its `parse::<u32>`
    // map_err.
    let err = parse_err("(?(99999999999)a|b)");
    assert!(err.msg.contains("invalid group reference"), "{}", err.msg);
}

// ----- Remaining class-escape / escape-code coverage -----

#[test]
fn parses_short_unicode_escape_in_class_form() {
    parse_pattern(r"[A]", 0).unwrap();
}

#[test]
fn err_class_short_unicode_escape_incomplete() {
    let err = parse_err(r"[\u00]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_class_long_unicode_escape_incomplete() {
    let err = parse_err(r"[\U0000]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_class_bad_letter_escape() {
    // `\q` inside a class is a bad-escape error.
    let err = parse_err(r"[\q]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_outer_unicode_escape_incomplete() {
    let err = parse_err(r"\u00");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn parses_class_escape_lookup_category() {
    // `\w` resolves to a category in class_escape. The Category branch's
    // "Ok" line at the top of class_escape isn't exercised by `[\d]`
    // alone because that goes through a different path; `[\w]` resolves
    // via `lookup_category`.
    parse_pattern(r"[\w]", 0).unwrap();
}

#[test]
fn err_groupref_decimal_overflow() {
    // A back-reference whose decimal number doesn't fit in u32 (12+
    // digits) trips the `dec.parse::<u32>()` error path.
    let err = parse_err(r"\9999999999999");
    assert!(err.msg.contains("bad escape") || err.msg.contains("invalid group reference"));
}

#[test]
fn err_decimal_backref_to_open_group_from_named() {
    // (?P=foo) inside its own definition body — open group reference
    // via the named-backref path.
    let err = parse_err(r"(?P<foo>(?P=foo))");
    assert!(
        err.msg.contains("cannot refer to an open group"),
        "{}",
        err.msg
    );
}

#[test]
fn err_subpattern_lookbehind_unterminated_lt() {
    // `(?<` at EOF — tokenizer fails to read the next char.
    let err = parse_err(r"(?<");
    assert!(err.msg.contains("unexpected end of pattern"), "{}", err.msg);
}

#[test]
fn err_subpattern_extension_unterminated_p() {
    // `(?P` at EOF.
    let err = parse_err(r"(?P");
    assert!(err.msg.contains("unexpected end of pattern"), "{}", err.msg);
}

#[test]
fn err_inline_flag_no_terminator() {
    // `(?i` at EOF.
    let err = parse_err(r"(?i");
    assert!(err.msg.contains("missing -, : or )"), "{}", err.msg);
}

#[test]
fn err_inline_flag_unknown_after_initial() {
    // `(?Z)` — Z is not a known flag.
    let err = parse_err(r"(?Z)");
    assert!(err.msg.contains("unknown flag") || err.msg.contains("unknown extension"));
}

#[test]
fn err_inline_flag_missing_after_dash() {
    let err = parse_err(r"(?i-");
    assert!(err.msg.contains("missing flag"), "{}", err.msg);
}

#[test]
fn err_inline_flag_disable_no_colon() {
    // `(?i-i` without `:` or `)` is rejected as turning a flag on and off.
    let err = parse_err(r"(?i-i:");
    assert!(err.msg.contains("flag turned on and off"), "{}", err.msg);
}

#[test]
fn err_inline_flag_disable_unknown() {
    let err = parse_err(r"(?-Z:abc)");
    assert!(err.msg.contains("unknown flag"), "{}", err.msg);
}

#[test]
fn err_repetition_too_large_braces() {
    // The brace-parsed repeat count overflows u64.
    let err = parse_err("a{9999999999999999999999}");
    assert!(
        err.msg.contains("repetition number is too large"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_max_repeat_with_only_lower_bound() {
    // `{3}` parses to an exact-3 repeat.
    parse_pattern("a{3}", 0).unwrap();
}

#[test]
fn err_repetition_with_repeat_after() {
    // Stacking two repeats is "multiple repeat".
    let err = parse_err(r"a{3}+?");
    assert!(err.msg.contains("multiple repeat"), "{}", err.msg);
}

// ----- Final-mile coverage: targeted parser error paths -----

#[test]
fn err_named_group_empty_at_open() {
    // `(?P<>x)`: empty name, hit immediately when getuntil sees `>` first.
    let err = parse_err("(?P<>x)");
    assert!(err.msg.contains("missing group name"), "{}", err.msg);
}

#[test]
fn err_named_group_eof_with_content() {
    // `(?P<foo`: getuntil consumes `foo`, then hits EOF.
    let err = parse_err("(?P<foo");
    assert!(err.msg.contains("missing >"), "{}", err.msg);
}

#[test]
fn err_named_backref_no_chars() {
    // `(?P=` with nothing after: getuntil sees EOF before any content.
    let err = parse_err("(?P=");
    assert!(err.msg.contains("missing group name"), "{}", err.msg);
}

#[test]
fn err_named_group_bad_char_at_open_via_getuntil() {
    // `(?P<1>x)` — name starts with a digit; rejected by `is_python_identifier`.
    let err = parse_err("(?P<1>x)");
    assert!(
        err.msg.contains("bad character in group name"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_class_with_long_unicode_escape() {
    // `[A]` covers the `\u` arm in class_escape with successful hex parsing.
    parse_pattern(r"[A]", 0).unwrap();
}

#[test]
fn err_class_escape_two_char_unknown_letter() {
    // `\h` is not recognised as a class escape; it's a bad escape.
    let err = parse_err(r"[\h]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_outer_octal_overflow() {
    // `\999999999999` doesn't parse as a u32 group reference.
    let err = parse_err(r"\99999999999");
    assert!(err.msg.contains("bad escape") || err.msg.contains("invalid group reference"));
}

#[test]
fn parses_class_unicode_short_escape_in_set() {
    // `A` parses successfully via the `\u`-in-class arm.
    parse_pattern(r"[A]", 0).unwrap();
}

#[test]
fn parses_two_class_alternation_flatten() {
    // `[a[b]]` flattens the inner positive class into the outer.
    parse_pattern(r"[a[b]]", 0).unwrap();
}

#[test]
fn parses_class_with_inner_class_that_blocks_flatten() {
    // `[a[^b]c]` — the negative inner class blocks flattening; the
    // outer class keeps it as a nested `In` set item.
    parse_pattern(r"[a[^b]c]", 0).unwrap();
}

#[test]
fn err_conditional_unknown_number_too_large() {
    // (?(N) where N parses as a valid u32 but exceeds MAXGROUPS:
    // the parser rejects it as `invalid group reference`.
    let many = "(?(99999)a|b)";
    let err = parse_err(many);
    assert!(err.msg.contains("invalid group reference"), "{}", err.msg);
}

// (?u-i:abc) is actually valid: u sets UNICODE locally, i is disabled.
// The "cannot turn on global flag" error fires only for a non-scoped
// `(?u-i)` (no colon) — that's already a different parse path.

#[test]
fn err_inline_flag_global_unknown() {
    // `(?xZ)` — Z is unknown after valid `x`.
    let err = parse_err("(?xZ)");
    assert!(err.msg.contains("unknown flag") || err.msg.contains("missing"));
}

#[test]
fn err_inline_flag_disable_global() {
    // `(?-u:abc)` — type-flags `a`, `u`, `L` cannot be turned off.
    let err = parse_err("(?-u:abc)");
    assert!(
        err.msg.contains("cannot turn off flags 'a', 'u' and 'L'"),
        "{}",
        err.msg
    );
}

#[test]
fn err_brace_repeat_overflow_lower() {
    // The {N,M} lower bound overflows u64.
    let err = parse_err("a{99999999999999999999,5}");
    assert!(
        err.msg.contains("repetition number is too large"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_eof_no_minus_colon_close() {
    // `(?i:` — colon-then-EOF leaves the subpattern unterminated.
    let err = parse_err("(?i:");
    assert!(err.msg.contains("missing )"), "{}", err.msg);
}

#[test]
fn parses_atomic_group_simple() {
    // Plain atomic group — exercises the AtomicGroup arm.
    parse_pattern(r"(?>abc)", 0).unwrap();
}

#[test]
fn parses_verbose_global_flag_in_subpattern() {
    // `(?x:a # comment\n b)` enables verbose locally.
    parse_pattern("(?x:a # comment\n b)", 0).unwrap();
}

#[test]
fn err_brace_repeat_max_overflow() {
    // `a{1,99999999999999999999}` — the upper bound exceeds u64 capacity.
    let err = parse_err("a{1,99999999999999999999}");
    assert!(
        err.msg.contains("repetition number is too large"),
        "{}",
        err.msg
    );
}

#[test]
fn err_repeat_at_start_of_pattern() {
    // `+abc` — repeat with nothing before it.
    let err = parse_err("+abc");
    assert!(err.msg.contains("nothing to repeat"), "{}", err.msg);
}

#[test]
fn err_repeat_after_anchor() {
    // `^?` — repeat applied to a position assertion is rejected.
    let err = parse_err(r"\A?");
    assert!(err.msg.contains("nothing to repeat"), "{}", err.msg);
}

#[test]
fn parses_quantifier_on_noncapturing_group() {
    // `(?:abc){3}` exercises the Subpattern{None, 0, 0, p} -> p unwrap
    // path in the brace repeat handling.
    parse_pattern("(?:abc){3}", 0).unwrap();
}

#[test]
fn parses_quantifier_on_noncapturing_group_optional() {
    // Same unwrap path but via `?` instead of `{}`.
    parse_pattern("(?:abc)?", 0).unwrap();
}

#[test]
fn parses_quantifier_on_noncapturing_group_lazy() {
    parse_pattern("(?:abc)*?", 0).unwrap();
}

#[test]
fn err_class_long_unicode_escape_unreachable_hex() {
    // 8 hex digits whose value exceeds 0x10FFFF aren't valid char32.
    let err = parse_err(r"[\U7FFFFFFF]");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn parses_class_with_class_escape_category() {
    // `[\d]` exercises the lookup_category path in class_escape that
    // returns Category(ChCode::Digit). The wrapping `[\d]` collapses
    // to a single-item In set.
    parse_pattern(r"[\d]", 0).unwrap();
}

#[test]
fn parses_class_short_unicode_escape_hex() {
    // `[A]` invokes class_escape's `Some('u')` arm with successful
    // hex parsing.
    parse_pattern("[\\u0041]", 0).unwrap();
}

#[test]
fn parses_outer_short_unicode_escape_hex() {
    // `A` invokes escape_code's `Some('u')` arm with successful parse.
    parse_pattern("\\u0041", 0).unwrap();
}

#[test]
fn parses_class_category_then_literal() {
    // `[\db]` — the `\d` returns Category, the `b` is a literal. Hits
    // the path where class_escape returns Category and is then folded
    // into the outer set alongside another literal.
    parse_pattern(r"[\db]", 0).unwrap();
}

#[test]
fn err_repeat_brace_max_exact_maxrepeat() {
    // `a{1,4294967295}` — max equals MAXREPEAT (u32::MAX), so the
    // `parsed >= MAXREPEAT` guard fires on the upper bound.
    let err = parse_err("a{1,4294967295}");
    assert!(
        err.msg.contains("repetition number is too large"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_nested_class_flatten_at_position_one() {
    // `[[abc]]` — outer class starts at position 0; the inner positive
    // class becomes the first set item, exercising the flatten branch.
    parse_pattern("[[abc]]", 0).unwrap();
}

#[test]
fn parses_class_literal_escape() {
    // `[\n]` parses `\n` via `lookup_escape_literal`, exercising the
    // first early-return in `class_escape`.
    parse_pattern(r"[\n]", 0).unwrap();
}

#[test]
fn parses_outer_octal_three_digit_padded() {
    // `\077` — three-digit octal escape in outer scope.
    parse_pattern(r"\077", 0).unwrap();
}

#[test]
fn err_outer_decimal_groupref_overflow_long() {
    // `\99999999999` doesn't fit in u32; the dec.parse u32 error fires.
    let err = parse_err(r"\99999999999");
    assert!(err.msg.contains("bad escape") || err.msg.contains("invalid group reference"));
}

#[test]
fn err_outer_escape_letter_unknown() {
    // `\h` (lone letter, not a recognized escape) is a bad escape.
    let err = parse_err(r"\h");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

#[test]
fn err_outer_unicode_short_incomplete_explicit() {
    // `\u123` (3 hex digits, not 4) — exercises the outer `\u` incomplete
    // path.
    let err = parse_err(r"\u123");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn parses_conditional_referencing_first_group() {
    // `(a)(?(1)b)` — conditional with valid group ref (no error path).
    parse_pattern("(a)(?(1)b)", 0).unwrap();
}

#[test]
fn err_conditional_named_unterminated() {
    let err = parse_err("(?(foo");
    assert!(err.msg.contains("missing )") || err.msg.contains("unknown group name"));
}

#[test]
fn err_inline_flag_global_then_invalid_letter() {
    // `(?xZ` — after the legitimate global `x`, `Z` is not a valid flag.
    let err = parse_err("(?xZ");
    assert!(err.msg.contains("unknown flag"), "{}", err.msg);
}

#[test]
fn err_inline_flag_after_minus_unknown() {
    // `(?-Z` — after the dash, an unknown letter.
    let err = parse_err("(?-Z");
    assert!(err.msg.contains("unknown flag") || err.msg.contains("missing"));
}

#[test]
fn err_inline_flag_disable_no_colon_close_paren() {
    // `(?i-i)` — after disabling, no colon and immediate close.
    let err = parse_err("(?i-i)");
    assert!(
        err.msg.contains("missing :") || err.msg.contains("flag turned on"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_global_unicode_then_dash() {
    // `(?u-i)` — disabling after a type-flag global is rejected by the
    // "cannot turn on global flag" path.
    let err = parse_err("(?u-i)");
    assert!(
        err.msg.contains("cannot turn on global flag") || err.msg.contains("missing :"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_class_with_class_escape_literal() {
    // `[\t]` exercises the lookup_escape_literal path returning a
    // Literal codepoint (for `\t` = 9).
    parse_pattern(r"[\t]", 0).unwrap();
}

#[test]
fn err_class_unicode_short_incomplete_explicit() {
    // `[\u12]` — 2 hex digits (expected 4).
    let err = parse_err(r"[\u12]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_outer_hex_escape_incomplete() {
    // `\x4` — 1 hex digit (expected 2) in outer scope.
    let err = parse_err(r"\x4");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_class_hex_escape_no_digits() {
    // `[\xz]` — `\x` followed by non-hex char.
    let err = parse_err(r"[\xz]");
    assert!(err.msg.contains("incomplete escape"), "{}", err.msg);
}

#[test]
fn err_outer_escape_punct_unknown() {
    // `\!` at the outer level is a literal, not an error. Stronger:
    // try `\#` which is also a literal.
    parse_pattern(r"\#", 0).unwrap();
}

#[test]
fn err_unknown_outer_escape_letter() {
    // `\Q` — uppercase non-recognized letter is a bad escape.
    let err = parse_err(r"\Q");
    assert!(err.msg.contains("bad escape"), "{}", err.msg);
}

// The non-letter `Some(ch)` branch of `class_escape` produces a literal
// when count == 2, so the punctuation-escape path is well-tested via the
// `[\!]` / `[\#]` tests; the count != 2 fallback is unreachable through
// the public API.

#[test]
fn parses_outer_octal_three_digits_returns() {
    // `\077` — three-digit octal hits the `return Ok(...Literal(n))`.
    parse_pattern(r"\077", 0).unwrap();
}

#[test]
fn parses_nested_class_flatten_inner_negated() {
    // `[a[^b]]` — the inner negated class is preserved (flatten_ok=false
    // branch), while the outer class accommodates it.
    parse_pattern("[a[^b]]", 0).unwrap();
}

#[test]
fn parses_nested_class_with_inner_class_and_more() {
    // `[a[bc]de]` — the inner positive class gets flattened, and the
    // outer class continues accumulating items afterwards.
    parse_pattern("[a[bc]de]", 0).unwrap();
}

#[test]
fn err_class_range_with_class_escape_endpoint_invalid() {
    // `[\d-z]` — `\d` is a category, not a literal, so it can't be a
    // range endpoint.
    let err = parse_err(r"[\d-z]");
    assert!(err.msg.contains("bad character range"), "{}", err.msg);
}

#[test]
fn err_conditional_named_unknown() {
    // (?(unknown_name)yes|no) — group name doesn't exist.
    let err = parse_err("(?(abc)x|y)");
    assert!(err.msg.contains("unknown group name"), "{}", err.msg);
}

#[test]
fn err_inline_flag_unknown_first_char() {
    // `(?-` followed by an unknown letter triggers a different path
    // than the `?-` ones tested above; the first letter is the
    // negative-flag letter directly.
    let err = parse_err("(?-Q)");
    assert!(err.msg.contains("missing flag") || err.msg.contains("unknown flag"));
}

#[test]
fn err_inline_flag_negate_global_in_subgroup() {
    // `(?u-i)abc` — turning off `i` after the global `u` triggers
    // "cannot turn on global flag" because `u` is a type flag.
    let err = parse_err("(?u-i)abc");
    assert!(
        err.msg.contains("cannot turn on global flag") || err.msg.contains("missing :"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_eof_after_dash_letter() {
    // `(?-i` — disable parsing but no `:` or `)`.
    let err = parse_err("(?-i");
    assert!(err.msg.contains("missing :"), "{}", err.msg);
}

#[test]
fn err_inline_flag_disable_global_at_end() {
    // `(?-u)abc` — try to globally disable a type flag.
    let err = parse_err("(?-u)abc");
    assert!(
        err.msg.contains("cannot turn off") || err.msg.contains("missing :"),
        "{}",
        err.msg
    );
}

#[test]
fn err_class_range_right_endpoint_is_class_escape() {
    // `[a-\d]` — right side is a category escape, not a literal, so
    // the range parser hits the class_escape branch and then errors
    // with "bad character range".
    let err = parse_err(r"[a-\d]");
    assert!(err.msg.contains("bad character range"), "{}", err.msg);
}

#[test]
fn parses_branch_flatten_with_set() {
    // `a|[bc]|d` — each branch is one op (Literal or In). The In
    // branch is positive, so the parser flattens everything into
    // a single `[abcd]` set.
    parse_pattern("a|[bc]|d", 0).unwrap();
}

#[test]
fn parses_branch_no_flatten_with_anchor() {
    // `a|\b|c` — one branch is an `At` (anchor), which the flatten
    // pass refuses, so the parser keeps it as a `Branch`.
    parse_pattern(r"a|\b|c", 0).unwrap();
}

#[test]
fn err_groupref_in_lookbehind_open_via_named_path() {
    // Named back-ref via `(?P=foo)` inside `(?<= ...)` where the
    // named group is being defined inside the same lookbehind.
    let err = parse_err(r"(?<=(?P<foo>(?P=foo)))");
    assert!(
        err.msg.contains("cannot refer to an open group")
            || err
                .msg
                .contains("cannot refer to group defined in the same lookbehind"),
        "{}",
        err.msg
    );
}

#[test]
fn parses_outer_octal_three_digit_non_zero_lead() {
    // `\107` — the parser sees `\1`, peeks digits, builds the 3-digit
    // octal `\107` = 71 ('G'), and returns through the in-range octal
    // arm of `escape_code`.
    parse_pattern(r"\107", 0).unwrap();
}

#[test]
fn err_outer_octal_three_digit_out_of_range() {
    // `\477` — 3-digit octal whose value exceeds 0o377.
    let err = parse_err(r"\477");
    assert!(err.msg.contains("octal escape value"), "{}", err.msg);
}

#[test]
fn err_conditional_named_unknown_named_after_first_group() {
    // (a)(?(unknown_name)yes|no) — the named group inside `(?(...)`
    // doesn't exist. Triggers the `unknown group name` error in
    // the conditional-backref path.
    let err = parse_err("(a)(?(unknown)x|y)");
    assert!(err.msg.contains("unknown group name"), "{}", err.msg);
}

#[test]
fn err_inline_flag_global_in_subgroup_via_partial_parse() {
    // `(?u)abc(?i)def` — second inline flag isn't at the start, so the
    // "global flags not at the start" path fires.
    let err = parse_err("(?u)abc(?i)def");
    assert!(
        err.msg.contains("global flags not at the start"),
        "{}",
        err.msg
    );
}

#[test]
fn err_inline_flag_eof_after_qmark_letter() {
    // `(?i` — letter but no `:`/`-`/`)`.
    let err = parse_err("(?i");
    assert!(err.msg.contains("missing -, : or )"), "{}", err.msg);
}

#[test]
fn err_inline_flag_disable_then_eof_after_letter() {
    // `(?i-i` — disable parsing reaches the "missing :" error before
    // detecting the on-and-off conflict (which fires only with `:`).
    let err = parse_err("(?i-i");
    assert!(err.msg.contains("missing :"), "{}", err.msg);
}

#[test]
fn err_inline_flag_after_enable_unknown_letter() {
    // `(?-iZ` — after disabling i, Z is an unknown letter.
    let err = parse_err("(?-iZ");
    assert!(err.msg.contains("unknown flag"), "{}", err.msg);
}

#[test]
fn err_inline_flag_disable_global_specifically() {
    // `(?i-L)` — try to disable LOCALE flag. Since this is a str
    // pattern, 'L' triggers the str-pattern error first; but the path
    // is also reachable via `(?i-u:abc)` which tries to disable a
    // global type-flag.
    let err = parse_err("(?i-u:abc)");
    assert!(
        err.msg.contains("cannot turn off") || err.msg.contains("global flag"),
        "{}",
        err.msg
    );
}

// ----- Group-name errors in different contexts -----

#[test]
fn err_named_group_starts_with_digit() {
    let err = parse_err("(?P<1abc>x)");
    assert!(err.msg.contains("bad character in group name"));
}

#[test]
fn err_named_backref_starts_with_digit() {
    let err = parse_err(r"(?P<foo>a)(?P=1foo)");
    assert!(
        err.msg.contains("bad character in group name") || err.msg.contains("unknown group name")
    );
}

#[test]
fn err_named_unterminated_no_terminator_char() {
    // (?P<foo at EOF without `>`.
    let err = parse_err("(?P<foo");
    assert!(err.msg.contains("missing >"));
}

// ----- Nested character class flatten paths -----

#[test]
fn parses_nested_negated_class_disables_flatten() {
    // `[a[^b]]` — the inner negated class prevents flattening and is
    // kept as a nested OpCode::In. The outer class then contains literal
    // `[` etc. as set items.
    parse_pattern("[a[^b]]", 0).unwrap();
}

// ----- Class range with escaped boundary -----

#[test]
fn err_class_range_with_category_endpoint() {
    // A category escape (`\d` etc.) is not a valid range endpoint.
    let err = parse_err(r"[\d-z]");
    assert!(err.msg.contains("bad character range"), "{}", err.msg);
}