basic-to-mindustry/tests/examples.rs

#![feature(fs_try_exists)]

use std::path::{Path, PathBuf};

use basic_to_mindustry::common::Config;
use basic_to_mindustry::compile::{
    optimize_constant, optimize_jump_always, optimize_jump_op, translate_ast,
};
use basic_to_mindustry::parse::{build_ast, tokenize};

fn read_basic_examples() -> impl Iterator<Item = (String, String)> {
    Path::new("./examples/")
        .read_dir()
        .unwrap()
        .filter_map(|entry| {
            let Ok(entry) = entry else {
                return None;
            };

            if entry
                .file_name()
                .into_string()
                .map(|name| name.ends_with(".basic"))
                .unwrap_or(false)
            {
                let file_name = entry.file_name().into_string().unwrap();
                let file = std::fs::read_to_string(entry.path()).unwrap_or_else(|e| {
                    panic!("Error opening {:?}: {:?}", file_name, e);
                });
                Some((file_name, file))
            } else {
                None
            }
        })
}

#[test]
fn test_examples() {
    let config = Config::default();

    for (file_name, file) in read_basic_examples() {
        let tokenized = tokenize(&file).unwrap_or_else(|e| {
            panic!("Error tokenizing {:?}: {:?}", file_name, e);
        });
        let parsed = build_ast(&tokenized, &config).unwrap_or_else(|e| {
            panic!("Error parsing {:?}: {:?}", file_name, e);
        });
        let translated = translate_ast(&parsed, &mut Default::default(), &config);
        let optimized = optimize_constant(translated);

        let _ = optimized;
    }
}

// TODO: implement proper equality of `MindustryProgram`s and parse the expected results instead
#[test]
fn test_examples_opt() {
    let config = Config::default();

    for (file_name, file) in read_basic_examples() {
        let Some(program_name) = PathBuf::from(file_name.clone())
            .file_stem()
            .and_then(|stem| stem.to_str())
            .map(|s| s.to_string())
        else {
            panic!(
                "Basic program in examples/ has an invalid filename: {}",
                file_name
            );
        };

        let opt_0 = format!("tests/examples/{}.0.mlog", program_name);
        if !std::fs::try_exists(&opt_0).unwrap() {
            continue;
        }

        let opt_0 = std::fs::read_to_string(opt_0).unwrap_or_else(|e| {
            panic!(
                "Couldn't open tests/examples/{}.0.mlog: {:?}",
                program_name, e
            );
        });

        let tokenized = tokenize(&file).unwrap_or_else(|e| {
            panic!("Error tokenizing {:?}: {:?}", file_name, e);
        });
        let parsed = build_ast(&tokenized, &config).unwrap_or_else(|e| {
            panic!("Error parsing {:?}: {:?}", file_name, e);
        });
        let translated = translate_ast(&parsed, &mut Default::default(), &config);

        pretty_assertions::assert_eq!(opt_0.trim(), format!("{}", translated).trim());

        let optimized = optimize_jump_always(optimize_jump_op(optimize_constant(translated)));

        let opt_1 = std::fs::read_to_string(format!("tests/examples/{}.1.mlog", program_name))
            .unwrap_or_else(|e| {
                panic!(
                    "Couldn't open tests/examples/{}.1.mlog: {:?}",
                    program_name, e
                );
            });

        pretty_assertions::assert_eq!(opt_1.trim(), format!("{}", optimized).trim());
    }
}