bashrs 6.66.0

//! Mutation-killing tests for Makefile generators
//!
//! These tests target specific mutation patterns identified by cargo-mutants
//! to improve mutation test coverage from 21.7% to ≥75%.
//!
//! Target file: rash/src/make_parser/generators.rs
//! Original kill rate: 13/60 (21.7%)
//! Target kill rate: ≥45/60 (75%)

#![allow(clippy::unwrap_used)] // Tests can use unwrap()

use bashrs::make_parser::ast::{MakeAst, MakeItem, MakeMetadata, RecipeMetadata, Span, VarFlavor};
use bashrs::make_parser::generators::{
    generate_purified_makefile_with_options, MakefileGeneratorOptions,
};

// =============================================================================
// BOUNDARY CONDITION TESTS
// =============================================================================
// These tests kill mutants that change comparison operators (>, >=, <, <=, ==)

#[test]
fn test_line_length_exact_boundary() {
    // Kills mutant: line.len() <= max_length → line.len() < max_length
    // Test case: line.len() == max_length should NOT be broken
    let makefile = MakeAst {
        items: vec![MakeItem::Variable {
            name: "VAR".to_string(),
            value: "a".repeat(74), // "VAR = " + 74 chars = 80 total
            flavor: VarFlavor::Recursive,
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(80),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Line should NOT be broken (it's exactly at boundary)
    assert_eq!(
        output.lines().count(),
        1,
        "Line at exact boundary should not be broken"
    );
    assert!(!output.contains('\\'), "No continuation needed at boundary");
}

// NOTE: Removed test_line_length_one_over_boundary - variable assignments
// are not broken by line length limits in current implementation

#[test]
fn test_word_boundary_exact_fit() {
    // Kills mutant: current_len + word_len > max_length → current_len + word_len >= max_length
    // Test case: current_len + word_len == max_length should fit
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "test".to_string(),
            prerequisites: vec![],
            recipe: vec![
                // "	" (tab) + "echo " + 73 chars = exactly 80
                format!("\techo {}", "a".repeat(73)),
            ],
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(80),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Recipe line that fits exactly should not be broken
    let recipe_lines: Vec<&str> = output.lines().filter(|l| l.starts_with('\t')).collect();
    assert_eq!(
        recipe_lines.len(),
        1,
        "Recipe fitting exactly should not break"
    );
}

// =============================================================================
// BOOLEAN LOGIC TESTS
// =============================================================================
// These tests kill mutants that change && to || (and vice versa)

#[test]
fn test_preserve_formatting_true_skip_removal_false() {
    // Kills mutant: || → &&
    // Test case: preserve_formatting=true, skip_blank_line_removal=false
    // Should preserve blank lines (OR logic)
    let makefile = MakeAst {
        items: vec![
            MakeItem::Target {
                name: "first".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo first".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
            MakeItem::Target {
                name: "second".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo second".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
        ],

        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        preserve_formatting: true,
        skip_blank_line_removal: false, // Different from above
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should have blank line between targets (OR logic means either flag works)
    assert!(
        output.contains("\n\nsecond:") || output.matches('\n').count() >= 3,
        "preserve_formatting=true should preserve blank lines even if skip_blank_line_removal=false"
    );
}

#[test]
fn test_preserve_formatting_false_skip_removal_true() {
    // Kills mutant: || → &&
    // Test case: preserve_formatting=false, skip_blank_line_removal=true
    // Should preserve blank lines (OR logic)
    let makefile = MakeAst {
        items: vec![
            MakeItem::Target {
                name: "first".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo first".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
            MakeItem::Target {
                name: "second".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo second".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
        ],

        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        preserve_formatting: false, // Different from above
        skip_blank_line_removal: true,
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should have blank line between targets (OR logic means either flag works)
    assert!(
        output.contains("\n\nsecond:") || output.matches('\n').count() >= 3,
        "skip_blank_line_removal=true should preserve blank lines even if preserve_formatting=false"
    );
}

#[test]
fn test_both_flags_false_removes_blanks() {
    // Kills mutant: || → &&
    // Test case: Both flags false should NOT preserve blank lines
    let makefile = MakeAst {
        items: vec![
            MakeItem::Target {
                name: "first".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo first".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
            MakeItem::Target {
                name: "second".to_string(),
                prerequisites: vec![],
                recipe: vec!["\techo second".to_string()],
                phony: false,
                recipe_metadata: Some(RecipeMetadata::default()),
                span: Span::dummy(),
            },
        ],

        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        preserve_formatting: false,
        skip_blank_line_removal: false,
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should NOT have extra blank lines when both flags are false
    assert!(
        !output.contains("\n\n\n"),
        "Both flags false should minimize blank lines"
    );
}

#[test]
fn test_line_break_logic_both_conditions() {
    // Kills mutant: && → ||
    // Test case: current_len + word_len > max_length AND current_len > indent.len()
    // Both must be true to break line
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "test".to_string(),
            prerequisites: vec![],
            recipe: vec![
                // Long line with indent
                format!("\t{}", "word ".repeat(30)), // Will exceed limit
            ],
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(40),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should break line because BOTH conditions are true
    assert!(
        output.contains('\\'),
        "Long line with indent should break when both conditions met"
    );
}

// =============================================================================
// ARITHMETIC TESTS
// =============================================================================
// These tests kill mutants that change arithmetic operators (+, -, *)

#[test]
fn test_word_length_calculation_includes_space() {
    // Kills mutant: word.len() + 1 → word.len() - 1
    // Test case: word_len must include +1 for space
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "test".to_string(),
            prerequisites: vec![],
            recipe: vec![
                // Each word is 5 chars, +1 space = 6 chars per word
                // At max_length=25, should fit 4 words exactly (24 chars + tab)
                "\tword1 word2 word3 word4".to_string(),
            ],
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(25),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Count spaces in output to verify word_len calculation
    let space_count = output.matches(' ').count();
    assert!(
        space_count >= 3,
        "Word length must include space (+1), got {} spaces",
        space_count
    );
}

#[test]
fn test_continuation_indent_adds_one() {
    // Kills mutant: indent.len() + 1 → indent.len() - 1
    // Test case: Continuation indent must be indent + 1 space
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "test".to_string(),
            prerequisites: vec![],
            recipe: vec![format!("\t{}", "word ".repeat(20))], // Force line break
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(30),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    eprintln!("Output:\n{}", output);
    eprintln!("Lines:");
    for (i, line) in output.lines().enumerate() {
        eprintln!("  {}: {:?}", i, line);
    }

    // Continuation lines should have extra space for continuation indent
    // The recipe starts with two tabs (one from recipe format, one from original input)
    // Continuation lines should have two tabs + space
    let continuation_lines: Vec<&str> = output
        .lines()
        .skip(2) // Skip target line and first recipe line
        .filter(|l| l.starts_with("\t\t "))
        .collect();

    assert!(
        !continuation_lines.is_empty(),
        "Should have continuation lines with indent + space. Output:\n{}",
        output
    );
}

// =============================================================================
// NEGATION TESTS
// =============================================================================
// These tests kill mutants that remove negation (! operator)

#[test]
fn test_backslash_negation_when_absent() {
    // Kills mutant: !current_line.ends_with('\\') → current_line.ends_with('\\')
    // Test case: Should add backslash when line does NOT end with one
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "test".to_string(),
            prerequisites: vec![],
            recipe: vec![format!("\t{}", "a ".repeat(50))], // Force break
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(40),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should add backslash for continuation
    assert!(
        output.contains(" \\"),
        "Should add backslash when line doesn't end with one"
    );
}

#[test]
fn test_blank_line_preservation_has_prev_false() {
    // Kills mutant: !has_prev → has_prev
    // Test case: First item should never have blank line before it
    let makefile = MakeAst {
        items: vec![MakeItem::Target {
            name: "first".to_string(),
            prerequisites: vec![],
            recipe: vec!["\techo test".to_string()],
            phony: false,
            recipe_metadata: Some(RecipeMetadata::default()),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        preserve_formatting: true,
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should NOT start with blank line
    assert!(
        !output.starts_with('\n'),
        "First item should not have blank line before it (!has_prev)"
    );
}

// =============================================================================
// EDGE CASES
// =============================================================================

#[test]
fn test_empty_line_handling() {
    // Edge case: empty lines should be handled gracefully
    let makefile = MakeAst {
        items: vec![MakeItem::Comment {
            text: "Test comment".to_string(),
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(80),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    assert!(!output.is_empty(), "Should handle empty lines");
}

#[test]
fn test_very_short_max_length() {
    // Boundary case: very short max_length (minimum practical value)
    let makefile = MakeAst {
        items: vec![MakeItem::Variable {
            name: "X".to_string(),
            value: "a b c".to_string(),
            flavor: VarFlavor::Recursive,
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(10), // Very short
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should handle gracefully without panic
    assert!(!output.is_empty(), "Should handle very short max_length");
}

#[test]
fn test_zero_indent_line_break() {
    // Edge case: line with no indent should still break properly
    let makefile = MakeAst {
        items: vec![MakeItem::Variable {
            name: "LONG_VAR".to_string(),
            value: "word ".repeat(30),
            flavor: VarFlavor::Recursive,
            span: Span::dummy(),
        }],
        metadata: MakeMetadata::default(),
    };

    let options = MakefileGeneratorOptions {
        max_line_length: Some(40),
        ..Default::default()
    };

    let output = generate_purified_makefile_with_options(&makefile, &options);

    // Should break even without indent
    assert!(
        output.lines().count() > 1,
        "Should break lines even without indent"
    );
}