rlox/tests/test_example.rs

use rlox::backend::interpreter::{EvaluateInterpreter, Interpreter};
use rlox::frontend::lexer::Lexer;
use rlox::frontend::parser::Parser;
use rlox::frontend::source_registry::SourceRegistry;
use std::fs;
use std::path::Path;

#[test]
fn test_all_examples() {
    let examples_dir = Path::new("examples");

    // Trova tutti i file .lox nella directory examples
    let entries = fs::read_dir(examples_dir).expect("Failed to read examples directory");

    let mut test_files_passed = Vec::new();
    let mut test_files_failed = Vec::new();
    let mut fail_files_passed = Vec::new();
    let mut fail_files_failed = Vec::new();

    for entry in entries {
        let entry = entry.expect("Failed to read directory entry");
        let path = entry.path();

        // Controlla se è un file .lox
        if path.extension().and_then(|s| s.to_str()) == Some("lox") {
            let file_name = path.file_name().unwrap().to_str().unwrap().to_string();

            // Ignora i file che non iniziano con test_ o fail_
            if !file_name.starts_with("test_") && !file_name.starts_with("fail_") {
                continue;
            }

            // Leggi il contenuto del file
            let source = match fs::read_to_string(&path) {
                Ok(content) => content,
                Err(e) => {
                    if file_name.starts_with("test_") {
                        test_files_failed.push((file_name, format!("Failed to read file: {}", e)));
                    } else {
                        fail_files_failed.push((file_name, format!("Failed to read file: {}", e)));
                    }
                    continue;
                }
            };

            // Esegui il file e categorizza il risultato
            match run_lox_file(source, &file_name) {
                Ok(_) => {
                    if file_name.starts_with("test_") {
                        test_files_passed.push(file_name);
                    } else {
                        fail_files_passed.push(file_name);
                    }
                }
                Err(error) => {
                    if file_name.starts_with("test_") {
                        test_files_failed.push((file_name, error));
                    } else {
                        fail_files_failed.push((file_name, error));
                    }
                }
            }
        }
    }

    // Stampa i risultati
    println!("\n========== TEST RESULTS ==========");

    // File test_ (dovrebbero passare)
    if !test_files_passed.is_empty() || !test_files_failed.is_empty() {
        println!("\n📝 TEST FILES (should pass):");
        if !test_files_passed.is_empty() {
            println!("  ✅ Passed ({}):", test_files_passed.len());
            for file in &test_files_passed {
                println!("     - {}", file);
            }
        }
        if !test_files_failed.is_empty() {
            println!("  ❌ Failed ({}):", test_files_failed.len());
            for (file, error) in &test_files_failed {
                println!("\n     - {}", file);
                println!("{}", error);
            }
        }
    }

    // File fail_ (dovrebbero fallire)
    if !fail_files_failed.is_empty() || !fail_files_passed.is_empty() {
        println!("\n🚫 FAIL FILES (should fail):");
        if !fail_files_failed.is_empty() {
            println!("  ✅ Failed as expected ({}):", fail_files_failed.len());
            for (file, error) in &fail_files_failed {
                println!("\n     - {}", file);
                println!("{}", error);
            }
        }
        if !fail_files_passed.is_empty() {
            println!("  ❌ Passed unexpectedly ({}):", fail_files_passed.len());
            for file in &fail_files_passed {
                println!("     - {} (should have failed but passed!)", file);
            }
        }
    }

    println!("\n==================================");

    // Riepilogo
    let total_test_files = test_files_passed.len() + test_files_failed.len();
    let total_fail_files = fail_files_passed.len() + fail_files_failed.len();
    let total_files = total_test_files + total_fail_files;

    println!("Summary:");
    if total_test_files > 0 {
        println!(
            "  test_ files: {}/{} passed",
            test_files_passed.len(),
            total_test_files
        );
    }
    if total_fail_files > 0 {
        println!(
            "  fail_ files: {}/{} failed (as expected)",
            fail_files_failed.len(),
            total_fail_files
        );
    }
    println!("  Total files tested: {}", total_files);

    // Assicurati che almeno un file sia stato testato
    assert!(
        total_files > 0,
        "No test_ or fail_ .lox files found in examples directory"
    );

    // Asserzioni per far fallire il test se le aspettative non sono rispettate
    if !test_files_failed.is_empty() {
        println!("\n❌ TEST FAILURE: The following test_ files failed but should have passed:");
        for (file, _) in &test_files_failed {
            println!("   - {}", file);
        }
        panic!(
            "{} test_ files failed unexpectedly",
            test_files_failed.len()
        );
    }

    if !fail_files_passed.is_empty() {
        println!("\n❌ TEST FAILURE: The following fail_ files passed but should have failed:");
        for file in &fail_files_passed {
            println!("   - {}", file);
        }
        panic!(
            "{} fail_ files passed unexpectedly",
            fail_files_passed.len()
        );
    }

    println!(
        "\n✅ All {} test/fail files behaved as expected!",
        total_files
    );
}

fn run_lox_file(source: String, _filename: &str) -> Result<(), String> {
    // Crea un source registry e mantienilo per il pretty printing degli errori
    let mut source_registry = SourceRegistry::new();

    // Aggiungi il source con il nome del file corretto
    let source_id = match source_registry.add_source_string(source.clone()) {
        Ok(id) => id,
        Err(e) => return Err(format!("Failed to add source: {}", e)),
    };

    // Tokenizza
    let source_content = source_registry.get_by_id(source_id).content.clone();
    let mut lexer = Lexer::new(source_content, source_id);
    let tokens = match lexer.scans_tokens() {
        Ok(tokens) => tokens,
        Err(err) => {
            // Usa il pretty printing con source context
            return Err(err.display_with_source(&source_registry));
        }
    };

    // Parsa
    let ast = match Parser::new(tokens).parse() {
        Ok(ast) => ast,
        Err(err) => {
            // Usa il pretty printing con source context
            return Err(err.display_with_source(&source_registry));
        }
    };

    // Esegui
    let mut interpreter = Interpreter::new();
    for stmt in ast.iter() {
        match interpreter.evaluate(stmt.clone()) {
            Ok(_) => {}
            Err(err) => {
                // Usa il pretty printing con source context
                return Err(err.display_with_source(&source_registry));
            }
        }
    }

    Ok(())
}