Finalizada Implementação do Interpretador de Testes

Testes agora armazenam TestResult no environment.

A função run_tests no interpretador recebe um programa, executa ele por inteiro e depois roda todos os testes presentes no programa, retornando um Vec<TestResult>

Testes definidos em um programa são armazenados no escopo no hashmap tests.

Vec<TestResult> ainda não está sendo armazenado no environment. Mas é possível implementar de maneira indolor.

Interpretador de Asserts finalizada, agora eles retornam Computation::Continue ou Err(e), com a string de erro presente dentro do Assert.

Cargo.toml agora requer uso de IndexMap para armazenar TestResults ordenados na ordem de definição dos testes.

Author: The3rdMega

Cargo.lock

@@ -7,3 +7,4 @@ edition = "2021"
 nom = "7.0"
 approx = "0.5.1"
 once_cell = "1.10"
+indexmap = "2.2"

Cargo.toml

@@ -1,6 +1,7 @@
 use crate::ir::ast::Function;
 use crate::ir::ast::Name;
 use crate::ir::ast::ValueConstructor;
+use indexmap::IndexMap;
 use std::collections::HashMap;
 use std::collections::LinkedList;
 
@@ -9,7 +10,7 @@ pub struct Scope<A> {
     pub variables: HashMap<Name, (bool, A)>,
     pub functions: HashMap<Name, Function>,
     pub adts: HashMap<Name, Vec<ValueConstructor>>,
-    pub tests: HashMap<Name, Function>,
+    pub tests: IndexMap<Name, Function>,
 }
 
 impl<A: Clone> Scope<A> {
@@ -18,7 +19,7 @@ impl<A: Clone> Scope<A> {
             variables: HashMap::new(),
             functions: HashMap::new(),
             adts: HashMap::new(),
-            tests: HashMap::new(),
+            tests: IndexMap::new(),
         }
     }
 
@@ -130,6 +131,19 @@ impl<A: Clone> Environment<A> {
         self.globals.lookup_test(name)
     }
 
+    pub fn scrape_tests(&self) -> Vec<Function> {
+        let mut tests = Vec::new();
+        for scope in self.stack.iter() {
+            for test in scope.tests.values() {
+                tests.push(test.clone());
+            }
+        }
+        for test in self.globals.tests.values() {
+            tests.push(test.clone());
+        }
+        tests
+    }
+
     pub fn lookup_adt(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
         for scope in self.stack.iter() {
             if let Some(cons) = scope.lookup_adt(name) {
@@ -174,6 +188,22 @@ impl<A: Clone> Environment<A> {
     }
 }
 
+pub struct TestResult {
+    pub name: Name,
+    pub result: bool,
+    pub error: Option<String>,
+}
+
+impl TestResult {
+    pub fn new(name: Name, result: bool, error: Option<String>) -> Self {
+        TestResult {
+            name,
+            result,
+            error,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/environment/environment.rs

@@ -1,5 +1,6 @@
 use super::expression_eval::{eval, ExpressionResult};
 use crate::environment::environment::Environment;
+use crate::environment::environment::TestResult;
 use crate::ir::ast::{Expression, Statement};
 
 pub enum Computation {
@@ -32,6 +33,42 @@ pub fn run(
     }
 }
 
+pub fn run_tests(stmt: &Statement) -> Result<Vec<TestResult>, String> {
+    let env = match run(stmt.clone(), &Environment::new()) {
+        Ok(env) => env,
+        Err(e) => return Err(e),
+    };
+
+    let mut results = Vec::new();
+
+    for test in env.scrape_tests() {
+        let test_env = env.clone();
+
+        let stmt = match &test.body {
+            Some(body) => *body.clone(),
+            None => continue,
+        };
+
+        match execute(stmt, &test_env) {
+            Ok(Computation::Continue(_)) | Ok(Computation::Return(_, _)) => {
+                results.push(TestResult::new(test.name.clone(), true, None));
+            }
+            Err(e) => {
+                results.push(TestResult::new(test.name.clone(), false, Some(e)));
+            }
+            Ok(Computation::PropagateError(e, _)) => {
+                results.push(TestResult::new(
+                    test.name.clone(),
+                    false,
+                    Some(format!("Propagated error: {:?}", e)),
+                ));
+            }
+        }
+    }
+
+    Ok(results)
+}
+
 pub fn execute(stmt: Statement, env: &Environment<Expression>) -> Result<Computation, String> {
     let mut new_env = env.clone();
 
@@ -1127,4 +1164,173 @@ mod tests {
             }
         }
     }
+    mod run_tests_tests {
+
+        use super::*;
+
+        #[test]
+        fn test_run_tests() {
+            let test_def = Statement::TestDef(Function {
+                name: "test_example".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CTrue),
+                    Box::new(Expression::CString("Test passed".to_string())),
+                )]))),
+            });
+            let programa = Statement::Block(vec![test_def.clone()]);
+            match run_tests(&programa) {
+                Ok(resultados) => {
+                    assert_eq!(resultados.len(), 1);
+                    assert_eq!(resultados[0].name, "test_example");
+                    assert!(resultados[0].result);
+                    assert!(resultados[0].error.is_none());
+                }
+                _ => panic!("Test execution failed"),
+            }
+        }
+
+        #[test]
+        fn test_run_tests_scope() {
+            let test_def = Statement::TestDef(Function {
+                name: "test_example".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CTrue),
+                    Box::new(Expression::CString("Test passed".to_string())),
+                )]))),
+            });
+
+            let teste_def2 = Statement::TestDef(Function {
+                name: "test_example2".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CTrue),
+                    Box::new(Expression::CString("Test 2 passed".to_string())),
+                )]))),
+            });
+
+            let assign1 = Statement::Assignment("x".to_string(), Box::new(Expression::CInt(10)));
+            let assign2 = Statement::Assignment("y".to_string(), Box::new(Expression::CInt(20)));
+
+            let ifelse = Statement::IfThenElse(
+                Box::new(Expression::CTrue),
+                Box::new(test_def),
+                Some(Box::new(teste_def2)),
+            );
+
+            let programa = Statement::Block(vec![assign1, assign2, ifelse]);
+
+            let resultado_final = match run_tests(&programa) {
+                Ok(resultados) => resultados,
+                Err(e) => panic!("Test execution failed: {}", e),
+            };
+
+            assert_eq!(resultado_final.len(), 1);
+            assert_eq!(resultado_final[0].name, "test_example");
+            assert_eq!(resultado_final[0].result, true);
+        }
+
+        #[test]
+        fn test_run_tests_with_assert_fail() {
+            let teste1 = Statement::TestDef(Function {
+                name: "test_fail".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CFalse),
+                    Box::new(Expression::CString("This test should fail".to_string())),
+                )]))),
+            });
+            let programa = Statement::Block(vec![teste1]);
+            match run_tests(&programa) {
+                Ok(resultados) => {
+                    assert_eq!(resultados.len(), 1);
+                    assert_eq!(resultados[0].name, "test_fail");
+                    assert!(!resultados[0].result);
+                    assert_eq!(
+                        resultados[0].error,
+                        Some("This test should fail".to_string())
+                    );
+                }
+                Err(e) => panic!("Test execution failed: {}", e),
+            }
+        }
+
+        #[test]
+        fn test_run_tests_without_asserts() {
+            let teste = Statement::TestDef(Function {
+                name: "test_no_assert".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::VarDeclaration(
+                    "x".to_string(),
+                    Box::new(Expression::CInt(42)),
+                )]))),
+            });
+            let programa = Statement::Block(vec![teste]);
+            match run_tests(&programa) {
+                Ok(resultados) => {
+                    assert_eq!(resultados.len(), 1);
+                    assert_eq!(resultados[0].name, "test_no_assert");
+                    assert!(resultados[0].result);
+                    assert!(resultados[0].error.is_none());
+                }
+                Err(e) => panic!("Test execution failed: {}", e),
+            }
+        }
+
+        #[test]
+        fn test_run_tests_with_multiple_tests() {
+            let teste1 = Statement::TestDef(Function {
+                name: "test_one".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CTrue),
+                    Box::new(Expression::CString("Test one passed".to_string())),
+                )]))),
+            });
+            let teste2 = Statement::TestDef(Function {
+                name: "test_two".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CFalse),
+                    Box::new(Expression::CString("Test two failed".to_string())),
+                )]))),
+            });
+            let teste3 = Statement::TestDef(Function {
+                name: "test_three".to_string(),
+                kind: Type::TVoid,
+                params: Vec::new(),
+                body: Some(Box::new(Statement::Block(vec![Statement::Assert(
+                    Box::new(Expression::CTrue),
+                    Box::new(Expression::CString("Test three passed".to_string())),
+                )]))),
+            });
+            let programa = Statement::Block(vec![teste1, teste2, teste3]);
+
+            match run_tests(&programa) {
+                Ok(resultados) => {
+                    assert_eq!(resultados.len(), 3);
+                    assert_eq!(resultados[0].name, "test_one");
+                    assert!(resultados[0].result);
+                    assert!(resultados[0].error.is_none());
+
+                    assert_eq!(resultados[1].name, "test_two");
+                    assert!(!resultados[1].result);
+                    assert_eq!(resultados[1].error, Some("Test two failed".to_string()));
+
+                    assert_eq!(resultados[2].name, "test_three");
+                    assert!(resultados[2].result);
+                    assert!(resultados[2].error.is_none());
+                }
+                Err(e) => panic!("Test execution failed: {}", e),
+            }
+        }
+    }
 }