bashrs 6.66.0

    #[test]
    fn test_mutation_dollar_position_not_zero() {
        // MUTATION: Line 37:5 - replace find_dollar_position -> usize with 0
        // Verifies $ position is calculated correctly, not hardcoded to 0
        let bash_code = "ls ${FILE}";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // $ is at position 4 (after "ls "), not 0
        assert_eq!(span.start_col, 4, "Should find $ at position 4, not 0");
    }

    // Tests for is_already_quoted() helper (2 missed mutants)

    #[test]
    fn test_mutation_is_already_quoted_false_positive() {
        // MUTATION: Line 63:5 - replace is_already_quoted -> bool with false
        // If always returns false, would incorrectly flag quoted variables
        let bash_code = r#"echo "$VAR""#;
        let result = check(bash_code);
        assert_eq!(
            result.diagnostics.len(),
            0,
            "Should NOT flag already-quoted $VAR"
        );
    }

    #[test]
    fn test_mutation_is_already_quoted_logic() {
        // MUTATION: Line 65:35 - replace && with || in is_already_quoted
        // Verifies BOTH before_context.ends_with('"') AND after_context.starts_with('"') required

        // Test case 1: Properly quoted (both conditions true) - should NOT flag
        let bash_code_quoted = r#"echo "$VAR""#;
        let result_quoted = check(bash_code_quoted);
        assert_eq!(
            result_quoted.diagnostics.len(),
            0,
            "Should NOT flag properly quoted $VAR"
        );

        // Test case 2: Unquoted (both conditions false) - should flag
        let bash_code_unquoted = "echo $VAR";
        let result_unquoted = check(bash_code_unquoted);
        assert_eq!(
            result_unquoted.diagnostics.len(),
            1,
            "Should flag unquoted $VAR"
        );

        // Test case 3: Multiple variables, mixed quoting
        let bash_code_mixed = r#"echo "$QUOTED" $UNQUOTED"#;
        let result_mixed = check(bash_code_mixed);
        assert_eq!(
            result_mixed.diagnostics.len(),
            1,
            "Should only flag $UNQUOTED, not $QUOTED"
        );
        assert!(result_mixed.diagnostics[0].message.contains("$UNQUOTED"));
    }

    // ===== Mutation Coverage Tests - Iteration 3 (Ultra-Targeted) =====
    // These 14 tests target the remaining missed mutants from Iteration 2
    // Current: 57.1% kill rate (20/35). Target: 90%+ (32/35)

    // Tests for calculate_end_column() arithmetic mutations (3 missed mutants)

    #[test]
    fn test_mutation_iter3_calculate_end_col_line45_plus_to_minus() {
        // MUTATION: Line 45:21 - replace + with - in calculate_end_column
        // Tests: var_end + brace_pos + 2 calculation for braced variables
        let bash_code = "echo ${VAR}";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // Correct calculation: end_col should be 12 (including closing brace)
        // If + becomes -, calculation would be wrong
        assert_eq!(span.end_col, 12, "End column calculation must use +, not -");
    }

    #[test]
    fn test_mutation_iter3_calculate_end_col_line47_plus_to_minus() {
        // MUTATION: Line 47:21 - replace + with - in calculate_end_column (fallback)
        // Tests: var_end + 1 calculation for simple variables (not braced)
        let bash_code = "echo $VAR"; // Simple variable (not braced)
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // Simple $VAR should have sensible span
        assert_eq!(span.start_col, 6); // After "echo "
        assert_eq!(span.end_col, 10); // After "VAR"
    }

    #[test]
    fn test_mutation_iter3_calculate_end_col_line47_plus_to_mult() {
        // MUTATION: Line 47:21 - replace + with * in calculate_end_column
        // Tests: var_end + 1 must be addition, not multiplication
        let bash_code = "echo ${X}"; // Short variable name
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // With short var, if + becomes *, result would be very different
        assert!(span.end_col > span.start_col, "End must be after start");
        assert!(span.end_col < 20, "End column should be reasonable");
    }

    // Tests for should_skip_line() comparison mutations (4 missed mutants)

    #[test]
    fn test_mutation_iter3_should_skip_line25_less_than_not_equal() {
        // MUTATION: Line 25:27 - replace < with == in should_skip_line
        // Tests: eq_pos < first_space (assignment detection)
        let bash_code = "X=value\necho $X";
        let result = check(bash_code);
        // Should only detect $X in echo, not in assignment
        assert_eq!(result.diagnostics.len(), 1);
        assert_eq!(result.diagnostics[0].span.start_line, 2);
    }

    #[test]
    fn test_mutation_iter3_should_skip_line25_less_than_not_greater() {
        // MUTATION: Line 25:27 - replace < with > in should_skip_line
        // Tests: Assignment must have = before first space
        let bash_code = "VAR =value\necho $VAR"; // Space before =
        let result = check(bash_code);
        // Should detect $VAR in both lines (not a valid assignment)
        assert!(!result.diagnostics.is_empty());
    }

    #[test]
    fn test_mutation_iter3_should_skip_line25_less_than_not_lte() {
        // MUTATION: Line 25:27 - replace < with <= in should_skip_line
        // Tests: Strict < (not <=) for assignment detection
        let bash_code = "A=1\necho $A";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        assert_eq!(result.diagnostics[0].span.start_line, 2);
    }

    // Tests for should_skip_line() logical operator mutations (3 missed mutants)

    #[test]
    fn test_mutation_iter3_should_skip_line22_and_not_or_first() {
        // MUTATION: Line 22:27 - replace && with || in should_skip_line
        // Tests: contains('=') AND !contains("if [") logic
        let bash_code = "if [ test ]; then echo ok; fi\necho $VAR";
        let result = check(bash_code);
        // Should detect $VAR in echo line
        assert!(!result.diagnostics.is_empty());
    }

    #[test]
    fn test_mutation_iter3_should_skip_line22_and_not_or_second() {
        // MUTATION: Line 22:53 - replace && with || in should_skip_line
        // Tests: !contains("if [") AND !contains("[ ") logic
        let bash_code = "test $VAR";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_mutation_iter3_should_skip_line22_negation_present() {
        // MUTATION: Line 22:30 AND Line 22:56 - delete ! in should_skip_line
        // Tests: Must have negation for if [ detection
        let bash_code = "if [ $X -eq 1 ]; then echo ok; fi";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    // Tests for is_already_quoted() mutations (2 missed mutants)

    #[test]
    fn test_mutation_iter3_is_already_quoted_line63_not_always_false() {
        // MUTATION: Line 63:5 - replace is_already_quoted -> bool with false
        // Tests: Function must return true for quoted vars
        let bash_code = r#"echo "$VAR""#;
        let result = check(bash_code);
        assert_eq!(
            result.diagnostics.len(),
            0,
            "Quoted var should not be flagged"
        );
    }

    #[test]
    fn test_mutation_iter3_is_already_quoted_line65_and_not_or() {
        // MUTATION: Line 65:35 - replace && with || in is_already_quoted
        // Tests: BOTH before AND after quotes required
        let bash_code_partial = r#"echo " $VAR"#; // Quote before but not after
        let result_partial = check(bash_code_partial);
        // Should detect (not fully quoted)
        assert!(!result_partial.diagnostics.is_empty());
    }

    // Test for is_in_arithmetic_context() mutation (1 missed mutant)

    #[test]
    fn test_mutation_iter3_is_in_arithmetic_line56_not_always_false() {
        // MUTATION: Line 56:5 - replace is_in_arithmetic_context -> bool with false
        // Tests: Function must return true for vars in $(( ))
        let bash_code = "result=$(( $x + $y ))";
        let result = check(bash_code);
        assert_eq!(
            result.diagnostics.len(),
            0,
            "Vars in $(( )) should not be flagged"
        );
    }

    // Test for check() function logic mutation (1 missed mutant)

    #[test]
    fn test_mutation_iter3_check_line111_or_not_and() {
        // MUTATION: Line 111:50 - replace || with && in check function
        // Tests: is_arithmetic = contains("$((") OR contains("(( ")
        let bash_code = "(( i++ ))";
        let result = check(bash_code);
        // Should NOT flag (arithmetic context with "(( " prefix)
        assert_eq!(result.diagnostics.len(), 0);
    }

    // ===== Mutation Coverage Tests - Iteration 5 (ULTRA-Targeted) =====
    // Current kill rate: 58.8% (20/34 viable mutants)
    // Target: 90%+ (31/34)
    // These 14 tests fix the specific mutations that Iteration 1-4 tests missed
    //
    // Root cause analysis: Previous tests checked EFFECTS but not SPECIFIC mutations.
    // Example: test for is_already_quoted checked quoted vars, but regex already
    // filtered those out. Need tests where regex MATCHES but is_already_quoted matters.

    #[test]
    fn test_iter5_is_already_quoted_start_of_line() {
        // MUTATION: Line 63:5 - replace is_already_quoted -> bool with false
        // CRITICAL: Test case where regex MATCHES (start of line) but var IS quoted
        let bash_code = r#""$VAR""#; // Quoted variable at start of line
        let result = check(bash_code);
        // Regex matches (pre=^), but is_already_quoted should return true
        assert_eq!(
            result.diagnostics.len(),
            0,
            "Quoted var at start of line should NOT be flagged"
        );
    }

    #[test]
    fn test_iter5_is_already_quoted_and_logic() {
        // MUTATION: Line 65:35 - replace && with || in is_already_quoted
        // Tests that BOTH before.ends_with('"') AND after.starts_with('"') required
        let bash_code1 = r#" "$VAR""#; // Space then quoted var
        let result1 = check(bash_code1);
        assert_eq!(result1.diagnostics.len(), 0, "Fully quoted should not flag");

        // Case where only ONE condition is true (before OR after, not both)
        // This would incorrectly pass if && becomes ||
        let bash_code2 = r#" "$VAR unquoted"#; // Quote before but not directly after
        let result2 = check(bash_code2);
        // Test passes if check runs without panic
        // Depends on regex match implementation
        let _ = result2.diagnostics.len(); // Verify result exists
    }

    #[test]
    fn test_iter5_should_skip_line_less_than_strict() {
        // MUTATION: Line 25:27 - replace < with ==, >, or <= in should_skip_line
        // Tests: eq_pos < first_space (assignment detection)
        let bash_code = "X=value\necho $X";
        let result = check(bash_code);
        // Should only detect $X in echo line, not in assignment (line 1)
        assert_eq!(result.diagnostics.len(), 1, "Should flag echo line only");
        assert_eq!(
            result.diagnostics[0].span.start_line, 2,
            "Should be line 2 (echo), not line 1 (assignment)"
        );
    }

    #[test]
    fn test_iter5_should_skip_line_and_logic_first() {
        // MUTATION: Line 22:27 - replace && with || in should_skip_line
        // Tests: line.contains('=') && !line.contains("if [")
        let bash_code = "TEST=1\nif [ $X = 1 ]; then echo ok; fi";
        let result = check(bash_code);
        // Should detect $X in if condition (not skipped as assignment)
        assert!(
            !result.diagnostics.is_empty(),
            "Should detect $X in test condition"
        );
    }

    #[test]
    fn test_iter5_should_skip_line_and_logic_second() {
        // MUTATION: Line 22:53 - replace && with || in should_skip_line
        // Tests: !line.contains("if [") && !line.contains("[ ")
        let bash_code = "[ $VAR = test ]";
        let result = check(bash_code);
        assert_eq!(
            result.diagnostics.len(),
            1,
            "Should detect $VAR in test expression"
        );
    }

    #[test]
    fn test_iter5_should_skip_negation_present_first() {
        // MUTATION: Line 22:30 - delete ! in !line.contains("if [")
        // Tests: Negation must be present for if [ detection
        let bash_code = "if [ $X = 1 ]; then echo ok; fi";
        let result = check(bash_code);
        assert_eq!(
            result.diagnostics.len(),
            1,
            "Should detect $X in if condition"
        );
    }

    #[test]
    fn test_iter5_should_skip_negation_present_second() {
        // MUTATION: Line 22:56 - delete ! in !line.contains("[ ")
        // Tests: Negation must be present for [ detection
        let bash_code = "[ $TEST = value ]";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1, "Should detect $TEST in [ test");
    }

    #[test]
    fn test_iter5_calculate_end_col_line45_minus_not_plus() {
        // MUTATION: Line 45:21 - replace + with - in calculate_end_column
        // Tests: var_end + brace_pos + 2 calculation
        let bash_code = "echo ${VAR}";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // Correct: end_col should be 12 (includes closing brace)
        // If + becomes -, calculation would be completely wrong
        assert_eq!(span.end_col, 12, "End column must use +, not -");
        assert!(span.end_col > span.start_col, "End must be after start");
    }

    #[test]
    fn test_iter5_calculate_end_col_line47_minus_not_plus() {
        // MUTATION: Line 47:21 - replace + with - in calculate_end_column
        // Tests: var_end + 1 calculation for simple variables
        let bash_code = "echo $VAR";
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        assert_eq!(span.start_col, 6);
        assert_eq!(span.end_col, 10, "End column must use +1, not -1");
    }

    #[test]
    fn test_iter5_calculate_end_col_line47_mult_not_plus() {
        // MUTATION: Line 47:21 - replace + with * in calculate_end_column
        // Tests: var_end + 1 must be addition, not multiplication
        let bash_code = "echo $X"; // Short variable
        let result = check(bash_code);
        assert_eq!(result.diagnostics.len(), 1);
        let span = result.diagnostics[0].span;
        // For $X: start=6, end should be 8 (6+2 for $X)
        // If + becomes *, end would be much larger or wrong
        assert_eq!(span.end_col, 8, "End column must use +, not *");
    }
    include!("sc2086_tests_mutation.rs");