From a65b4aa47193044bdabb44ab8e577f1870b056b6 Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Wed, 7 Dec 2022 09:57:01 -0500
Subject: [PATCH 01/18] feat: add test def and test token

---
 crates/lang/src/ast.rs          | 8 ++++++--
 crates/lang/src/parser/lexer.rs | 1 +
 crates/lang/src/parser/token.rs | 2 ++
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/lang/src/ast.rs b/crates/lang/src/ast.rs
index 93a70889..3afbdd82 100644
--- a/crates/lang/src/ast.rs
+++ b/crates/lang/src/ast.rs
@@ -138,6 +138,8 @@ pub enum Definition<T, Expr, ConstantRecordTag, PackageName> {
     Use(Use<PackageName>),
 
     ModuleConstant(ModuleConstant<T, ConstantRecordTag>),
+
+    Test(Function<T, Expr>),
 }
 
 impl<A, B, C, E> Definition<A, B, C, E> {
@@ -147,7 +149,8 @@ impl<A, B, C, E> Definition<A, B, C, E> {
             | Definition::Use(Use { location, .. })
             | Definition::TypeAlias(TypeAlias { location, .. })
             | Definition::DataType(DataType { location, .. })
-            | Definition::ModuleConstant(ModuleConstant { location, .. }) => *location,
+            | Definition::ModuleConstant(ModuleConstant { location, .. })
+            | Definition::Test(Function { location, .. }) => *location,
         }
     }
 
@@ -157,7 +160,8 @@ impl<A, B, C, E> Definition<A, B, C, E> {
             Definition::Fn(Function { doc, .. })
             | Definition::TypeAlias(TypeAlias { doc, .. })
             | Definition::DataType(DataType { doc, .. })
-            | Definition::ModuleConstant(ModuleConstant { doc, .. }) => {
+            | Definition::ModuleConstant(ModuleConstant { doc, .. })
+            | Definition::Test(Function { doc, .. }) => {
                 let _ = std::mem::replace(doc, Some(new_doc));
             }
         }
diff --git a/crates/lang/src/parser/lexer.rs b/crates/lang/src/parser/lexer.rs
index 1d140384..d845b741 100644
--- a/crates/lang/src/parser/lexer.rs
+++ b/crates/lang/src/parser/lexer.rs
@@ -67,6 +67,7 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = ParseError> {
         "check" => Token::Assert,
         "const" => Token::Const,
         "fn" => Token::Fn,
+        "test" => Token::Test,
         "if" => Token::If,
         "else" => Token::Else,
         "is" => Token::Is,
diff --git a/crates/lang/src/parser/token.rs b/crates/lang/src/parser/token.rs
index 8faaa339..0811268a 100644
--- a/crates/lang/src/parser/token.rs
+++ b/crates/lang/src/parser/token.rs
@@ -68,6 +68,7 @@ pub enum Token {
     Opaque,
     Pub,
     Use,
+    Test,
     Todo,
     Trace,
     Type,
@@ -145,6 +146,7 @@ impl fmt::Display for Token {
             Token::Todo => "todo",
             Token::Trace => "try",
             Token::Type => "type",
+            Token::Test => "test",
         };
         write!(f, "\"{}\"", s)
     }

From ea487478250ac2f938cdc41a3b9542ccf0dbde98 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Wed, 7 Dec 2022 16:21:16 +0100
Subject: [PATCH 02/18] Extend parser for 'test' keyword.

---
 crates/lang/src/format.rs | 23 +++++++++++++++++++++--
 crates/lang/src/parser.rs | 31 +++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 2 deletions(-)

diff --git a/crates/lang/src/format.rs b/crates/lang/src/format.rs
index 71e76d10..9a60bfca 100644
--- a/crates/lang/src/format.rs
+++ b/crates/lang/src/format.rs
@@ -215,7 +215,24 @@ impl<'comments> Formatter<'comments> {
                 return_annotation,
                 end_position,
                 ..
-            }) => self.definition_fn(public, name, args, return_annotation, body, *end_position),
+            }) => self.definition_fn(
+                public,
+                "fn",
+                name,
+                args,
+                return_annotation,
+                body,
+                *end_position,
+            ),
+
+            Definition::Test(Function {
+                name,
+                arguments: args,
+                body,
+                public,
+                end_position,
+                ..
+            }) => self.definition_fn(public, "test", name, args, &None, body, *end_position),
 
             Definition::TypeAlias(TypeAlias {
                 alias,
@@ -496,6 +513,7 @@ impl<'comments> Formatter<'comments> {
     fn definition_fn<'a>(
         &mut self,
         public: &'a bool,
+        keyword: &'a str,
         name: &'a str,
         args: &'a [UntypedArg],
         return_annotation: &'a Option<Annotation>,
@@ -504,7 +522,8 @@ impl<'comments> Formatter<'comments> {
     ) -> Document<'a> {
         // Fn name and args
         let head = pub_(*public)
-            .append("fn ")
+            .append(keyword)
+            .append(" ")
             .append(name)
             .append(wrap_args(args.iter().map(|e| (self.fn_arg(e), false))));
 
diff --git a/crates/lang/src/parser.rs b/crates/lang/src/parser.rs
index d92e7e31..e7275c6d 100644
--- a/crates/lang/src/parser.rs
+++ b/crates/lang/src/parser.rs
@@ -74,6 +74,7 @@ fn module_parser() -> impl Parser<Token, Vec<UntypedDefinition>, Error = ParseEr
         data_parser(),
         type_alias_parser(),
         fn_parser(),
+        test_parser(),
         constant_parser(),
     ))
     .repeated()
@@ -266,6 +267,36 @@ pub fn fn_parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseEr
         )
 }
 
+pub fn test_parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
+    just(Token::Test)
+        .ignore_then(select! {Token::Name {name} => name})
+        .then_ignore(just(Token::LeftParen))
+        .then_ignore(just(Token::RightParen))
+        .map_with_span(|name, span| (name, span))
+        .then(
+            expr_seq_parser()
+                .or_not()
+                .delimited_by(just(Token::LeftBrace), just(Token::RightBrace)),
+        )
+        .map_with_span(|((name, span_end), body), span| {
+            ast::UntypedDefinition::Fn(ast::Function {
+                arguments: vec![],
+                body: body.unwrap_or(expr::UntypedExpr::Todo {
+                    kind: TodoKind::EmptyFunction,
+                    location: span,
+                    label: None,
+                }),
+                doc: None,
+                location: span_end,
+                end_position: span.end - 1,
+                name,
+                public: true,
+                return_annotation: None,
+                return_type: (),
+            })
+        })
+}
+
 fn constant_parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
     pub_parser()
         .or_not()

From bc785673b2c2537f1dc514819523956cb1b40ceb Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 14:45:26 +0100
Subject: [PATCH 03/18] Fix compilation errors for the newly introduce test &
 add type inference.

  Tests are basically functions for which the return type should unify with bool. In principle, the type checker could also check that a test function has no arguments but, a test function with arguments wouldn't parse in the first place; feels a bit hacky but it works when considering the pipeline as a whole.

  Note that the code generation is still to be done.
---
 crates/lang/src/parser.rs           |  2 +-
 crates/lang/src/tipo/environment.rs | 24 +++++++++++++++++++++++-
 crates/lang/src/tipo/infer.rs       | 14 +++++++++++++-
 crates/project/src/lib.rs           |  3 +++
 examples/sample/validators/swap.ak  |  4 ++++
 5 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/crates/lang/src/parser.rs b/crates/lang/src/parser.rs
index e7275c6d..d2c98f1c 100644
--- a/crates/lang/src/parser.rs
+++ b/crates/lang/src/parser.rs
@@ -279,7 +279,7 @@ pub fn test_parser() -> impl Parser<Token, ast::UntypedDefinition, Error = Parse
                 .delimited_by(just(Token::LeftBrace), just(Token::RightBrace)),
         )
         .map_with_span(|((name, span_end), body), span| {
-            ast::UntypedDefinition::Fn(ast::Function {
+            ast::UntypedDefinition::Test(ast::Function {
                 arguments: vec![],
                 body: body.unwrap_or(expr::UntypedExpr::Todo {
                     kind: TodoKind::EmptyFunction,
diff --git a/crates/lang/src/tipo/environment.rs b/crates/lang/src/tipo/environment.rs
index ca9b6055..4f70deff 100644
--- a/crates/lang/src/tipo/environment.rs
+++ b/crates/lang/src/tipo/environment.rs
@@ -255,6 +255,7 @@ impl<'a> Environment<'a> {
             definition @ (Definition::TypeAlias { .. }
             | Definition::DataType { .. }
             | Definition::Use { .. }
+            | Definition::Test { .. }
             | Definition::ModuleConstant { .. }) => definition,
         }
     }
@@ -911,7 +912,10 @@ impl<'a> Environment<'a> {
                 }
             }
 
-            Definition::Fn { .. } | Definition::Use { .. } | Definition::ModuleConstant { .. } => {}
+            Definition::Fn { .. }
+            | Definition::Test { .. }
+            | Definition::Use { .. }
+            | Definition::ModuleConstant { .. } => {}
         }
 
         Ok(())
@@ -990,6 +994,24 @@ impl<'a> Environment<'a> {
                 }
             }
 
+            Definition::Test(Function { name, location, .. }) => {
+                hydrators.insert(name.clone(), Hydrator::new());
+                let arg_types = vec![];
+                let return_type = builtins::bool();
+                self.insert_variable(
+                    name.clone(),
+                    ValueConstructorVariant::ModuleFn {
+                        name: name.clone(),
+                        field_map: None,
+                        module: module_name.to_owned(),
+                        arity: 0,
+                        location: *location,
+                        builtin: None,
+                    },
+                    function(arg_types, return_type),
+                );
+            }
+
             Definition::DataType(DataType {
                 location,
                 public,
diff --git a/crates/lang/src/tipo/infer.rs b/crates/lang/src/tipo/infer.rs
index 907b731d..9fc64e0a 100644
--- a/crates/lang/src/tipo/infer.rs
+++ b/crates/lang/src/tipo/infer.rs
@@ -6,6 +6,7 @@ use crate::{
         RecordConstructorArg, TypeAlias, TypedDefinition, TypedModule, UntypedDefinition,
         UntypedModule, Use,
     },
+    builtins,
     builtins::function,
     parser::token::Token,
     IdGenerator,
@@ -66,8 +67,8 @@ impl UntypedModule {
         for def in self.definitions().cloned() {
             match def {
                 Definition::ModuleConstant { .. } => consts.push(def),
-
                 Definition::Fn { .. }
+                | Definition::Test { .. }
                 | Definition::TypeAlias { .. }
                 | Definition::DataType { .. }
                 | Definition::Use { .. } => not_consts.push(def),
@@ -233,6 +234,17 @@ fn infer_definition(
             }))
         }
 
+        Definition::Test(f) => {
+            if let Definition::Fn(f) =
+                infer_definition(Definition::Fn(f), module_name, hydrators, environment)?
+            {
+                environment.unify(f.return_type.clone(), builtins::bool(), f.location)?;
+                Ok(Definition::Test(f))
+            } else {
+                unreachable!("test defintion inferred as something else than a function?")
+            }
+        }
+
         Definition::TypeAlias(TypeAlias {
             doc,
             location,
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index ab44c08d..e580c803 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -336,6 +336,9 @@ impl Project {
                             func,
                         );
                     }
+                    Definition::Test(_) => {
+                        todo!()
+                    }
                     Definition::TypeAlias(ta) => {
                         type_aliases.insert((module.name.clone(), ta.alias.clone()), ta);
                     }
diff --git a/examples/sample/validators/swap.ak b/examples/sample/validators/swap.ak
index e1bc32b2..8764f3b6 100644
--- a/examples/sample/validators/swap.ak
+++ b/examples/sample/validators/swap.ak
@@ -11,3 +11,7 @@ pub fn spend(datum: sample.Datum, rdmr: sample.Redeemer, _ctx: Nil) -> Bool {
 
   z == #(#[222], #[222])
 }
+
+test foo() {
+  1 + 1 == 2
+}

From 384c4daa4a8eed7c074a2bb6154e953c258f0e30 Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 10:01:24 -0500
Subject: [PATCH 04/18] feat: add test_gen function

---
 crates/lang/src/format.rs |  1 +
 crates/project/src/lib.rs | 92 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 89 insertions(+), 4 deletions(-)

diff --git a/crates/lang/src/format.rs b/crates/lang/src/format.rs
index 9a60bfca..3dcc4775 100644
--- a/crates/lang/src/format.rs
+++ b/crates/lang/src/format.rs
@@ -510,6 +510,7 @@ impl<'comments> Formatter<'comments> {
         commented(doc, comments)
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn definition_fn<'a>(
         &mut self,
         public: &'a bool,
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index e580c803..96610cbc 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -85,7 +85,12 @@ impl Project {
         self.compile(false, false)
     }
 
-    pub fn compile(&mut self, uplc_gen: bool, uplc_dump: bool) -> Result<(), Error> {
+    pub fn compile(
+        &mut self,
+        uplc_gen: bool,
+        uplc_dump: bool,
+        run_tests: bool,
+    ) -> Result<(), Error> {
         self.read_source_files()?;
 
         let parsed_modules = self.parse_sources()?;
@@ -336,9 +341,7 @@ impl Project {
                             func,
                         );
                     }
-                    Definition::Test(_) => {
-                        todo!()
-                    }
+                    Definition::Test(_) => {}
                     Definition::TypeAlias(ta) => {
                         type_aliases.insert((module.name.clone(), ta.alias.clone()), ta);
                     }
@@ -388,6 +391,87 @@ impl Project {
         Ok(programs)
     }
 
+    // TODO: revisit ownership and lifetimes of data in this function
+    fn test_gen(&mut self, checked_modules: &CheckedModules) -> Result<Vec<Script>, Error> {
+        let mut programs = Vec::new();
+        let mut functions = HashMap::new();
+        let mut type_aliases = HashMap::new();
+        let mut data_types = HashMap::new();
+        let mut imports = HashMap::new();
+        let mut constants = HashMap::new();
+
+        // let mut indices_to_remove = Vec::new();
+        let mut tests = Vec::new();
+
+        for module in checked_modules.values() {
+            for (_index, def) in module.ast.definitions().enumerate() {
+                match def {
+                    Definition::Fn(func) => {
+                        functions.insert(
+                            FunctionAccessKey {
+                                module_name: module.name.clone(),
+                                function_name: func.name.clone(),
+                            },
+                            func,
+                        );
+                    }
+                    Definition::Test(func) => {
+                        tests.push((module.name.clone(), func));
+                        // indices_to_remove.push(index);
+                    }
+                    Definition::TypeAlias(ta) => {
+                        type_aliases.insert((module.name.clone(), ta.alias.clone()), ta);
+                    }
+                    Definition::DataType(dt) => {
+                        data_types.insert(
+                            DataTypeKey {
+                                module_name: module.name.clone(),
+                                defined_type: dt.name.clone(),
+                            },
+                            dt,
+                        );
+                    }
+                    Definition::Use(import) => {
+                        imports.insert((module.name.clone(), import.module.join("/")), import);
+                    }
+                    Definition::ModuleConstant(mc) => {
+                        constants.insert((module.name.clone(), mc.name.clone()), mc);
+                    }
+                }
+            }
+
+            // for index in indices_to_remove.drain(0..) {
+            //     module.ast.definitions.remove(index);
+            // }
+        }
+
+        for (module_name, func_def) in tests {
+            let Function {
+                arguments,
+                name,
+                body,
+                ..
+            } = func_def;
+
+            let mut generator = CodeGenerator::new(
+                &functions,
+                // &type_aliases,
+                &data_types,
+                // &imports,
+                // &constants,
+                &self.module_types,
+            );
+
+            let program = generator.generate(body.clone(), arguments.clone());
+
+            let script = Script::new(module_name, name.to_string(), program.try_into().unwrap());
+
+            programs.push(script);
+        }
+
+        Ok(programs)
+    }
+
     fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {
         let assets = self.root.join("assets");
 

From 4cdb5d8d02aa052564319eb7c0cf2c66f06c862d Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 16:23:21 +0100
Subject: [PATCH 05/18] Implement test runner.

  easy.
---
 crates/project/src/lib.rs | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 96610cbc..a1f9552a 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -78,11 +78,11 @@ impl Project {
     }
 
     pub fn build(&mut self, uplc: bool) -> Result<(), Error> {
-        self.compile(true, uplc)
+        self.compile(true, uplc, false)
     }
 
     pub fn check(&mut self) -> Result<(), Error> {
-        self.compile(false, false)
+        self.compile(false, false, true)
     }
 
     pub fn compile(
@@ -101,12 +101,19 @@ impl Project {
 
         let validators = self.validate_validators(&mut checked_modules)?;
 
+        // TODO: In principle, uplc_gen and run_tests can't be true together. We probably want to
+        // model the options differently to make it obvious at the type-level.
         if uplc_gen {
             let programs = self.code_gen(validators, &checked_modules)?;
 
             self.write_build_outputs(programs, uplc_dump)?;
         }
 
+        if run_tests {
+            let tests = self.test_gen(&checked_modules)?;
+            self.run_tests(tests);
+        }
+
         Ok(())
     }
 
@@ -472,6 +479,21 @@ impl Project {
         Ok(programs)
     }
 
+    fn run_tests(&self, tests: Vec<Script>) {
+        for test in tests {
+            let result = test.program.eval();
+            match result {
+                (Ok(..), _, _) => {
+                    println!("{}::{} ✓", test.module, test.name);
+                }
+                (Err(e), _, _) => {
+                    println!("{}::{} x", test.module, test.name);
+                    println!("{}", e);
+                }
+            }
+        }
+    }
+
     fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {
         let assets = self.root.join("assets");
 

From f250d3df84a95ba053bacb396d643ec18bf5cb80 Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 10:55:27 -0500
Subject: [PATCH 06/18] feat: eval should take initial budget

---
 crates/cli/src/cmd/uplc/eval.rs | 6 +++---
 crates/uplc/src/ast.rs          | 6 ++++--
 crates/uplc/src/tx/eval.rs      | 4 ++--
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/crates/cli/src/cmd/uplc/eval.rs b/crates/cli/src/cmd/uplc/eval.rs
index 8d251fb0..70c86858 100644
--- a/crates/cli/src/cmd/uplc/eval.rs
+++ b/crates/cli/src/cmd/uplc/eval.rs
@@ -61,7 +61,9 @@ pub fn exec(
         program = program.apply_term(&term);
     }
 
-    let (term, cost, logs) = program.eval();
+    let budget = ExBudget::default();
+
+    let (term, cost, logs) = program.eval(budget);
 
     match term {
         Ok(term) => {
@@ -74,8 +76,6 @@ pub fn exec(
         }
     }
 
-    let budget = ExBudget::default();
-
     println!(
         "\nCosts\n-----\ncpu: {}\nmemory: {}",
         budget.cpu - cost.cpu,
diff --git a/crates/uplc/src/ast.rs b/crates/uplc/src/ast.rs
index d8019604..8306e1e7 100644
--- a/crates/uplc/src/ast.rs
+++ b/crates/uplc/src/ast.rs
@@ -495,6 +495,7 @@ impl From<Term<FakeNamedDeBruijn>> for Term<NamedDeBruijn> {
 impl Program<NamedDeBruijn> {
     pub fn eval(
         &self,
+        initial_budget: ExBudget,
     ) -> (
         Result<Term<NamedDeBruijn>, crate::machine::Error>,
         ExBudget,
@@ -503,7 +504,7 @@ impl Program<NamedDeBruijn> {
         let mut machine = Machine::new(
             Language::PlutusV2,
             CostModel::default(),
-            ExBudget::default(),
+            initial_budget,
             200,
         );
 
@@ -558,6 +559,7 @@ impl Program<NamedDeBruijn> {
 impl Program<DeBruijn> {
     pub fn eval(
         &self,
+        initial_budget: ExBudget,
     ) -> (
         Result<Term<NamedDeBruijn>, crate::machine::Error>,
         ExBudget,
@@ -565,7 +567,7 @@ impl Program<DeBruijn> {
     ) {
         let program: Program<NamedDeBruijn> = self.clone().into();
 
-        program.eval()
+        program.eval(initial_budget)
     }
 }
 
diff --git a/crates/uplc/src/tx/eval.rs b/crates/uplc/src/tx/eval.rs
index 9684c8e3..2c08f0bb 100644
--- a/crates/uplc/src/tx/eval.rs
+++ b/crates/uplc/src/tx/eval.rs
@@ -786,7 +786,7 @@ pub fn eval_redeemer(
 
                         program.eval_as(&Language::PlutusV2, costs, initial_budget)
                     } else {
-                        program.eval()
+                        program.eval(ExBudget::default())
                     };
 
                     match result {
@@ -889,7 +889,7 @@ pub fn eval_redeemer(
 
                         program.eval_as(&Language::PlutusV2, costs, initial_budget)
                     } else {
-                        program.eval()
+                        program.eval(ExBudget::default())
                     };
 
                     match result {

From 141a9aef307744ef7337b15ad9fc65a4171aac97 Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 10:56:53 -0500
Subject: [PATCH 07/18] feat: impl Sub for ExBudget

---
 crates/uplc/src/machine/cost_model.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/crates/uplc/src/machine/cost_model.rs b/crates/uplc/src/machine/cost_model.rs
index 98be17e7..0131d0e1 100644
--- a/crates/uplc/src/machine/cost_model.rs
+++ b/crates/uplc/src/machine/cost_model.rs
@@ -47,6 +47,17 @@ impl Default for ExBudget {
     }
 }
 
+impl std::ops::Sub for ExBudget {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        ExBudget {
+            mem: self.mem - rhs.mem,
+            cpu: self.cpu - rhs.cpu,
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct CostModel {
     pub machine_costs: MachineCosts,

From e9d8e1d31702e201f2b9c206b3dcc909ca3018b9 Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 10:57:13 -0500
Subject: [PATCH 08/18] feat: print budget consumed by test

---
 crates/project/src/error.rs        |  2 +-
 crates/project/src/lib.rs          | 34 ++++++++++++++++++++++++------
 examples/sample/validators/swap.ak |  2 +-
 3 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/crates/project/src/error.rs b/crates/project/src/error.rs
index 46548e41..a1bc12f9 100644
--- a/crates/project/src/error.rs
+++ b/crates/project/src/error.rs
@@ -293,7 +293,7 @@ impl Diagnostic for Warning {
 
     fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
         match self {
-            Warning::Type { .. } => Some(Box::new("aiken::typecheck")),
+            Warning::Type { .. } => Some(Box::new("aiken::check")),
         }
     }
 }
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index a1f9552a..0138bc49 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -25,7 +25,10 @@ use pallas::{
 use pallas_traverse::ComputeHash;
 use script::Script;
 use serde_json::json;
-use uplc::ast::{DeBruijn, Program};
+use uplc::{
+    ast::{DeBruijn, Program},
+    machine::cost_model::ExBudget,
+};
 
 use crate::{
     config::Config,
@@ -481,14 +484,31 @@ impl Project {
 
     fn run_tests(&self, tests: Vec<Script>) {
         for test in tests {
-            let result = test.program.eval();
+            // TODO: in the future we probably just want to be able to
+            // tell the machine to not explode on budget consumption.
+            let initial_budget = ExBudget {
+                mem: i64::MAX,
+                cpu: i64::MAX,
+            };
+
+            let result = test.program.eval(initial_budget);
+
             match result {
-                (Ok(..), _, _) => {
-                    println!("{}::{} ✓", test.module, test.name);
+                (Ok(..), remaining_budget, _) => {
+                    let ExBudget { mem, cpu } = initial_budget - remaining_budget;
+
+                    println!(
+                        "    [PASS] [mem: {}, cpu: {}] {}::{}",
+                        mem, cpu, test.module, test.name
+                    );
                 }
-                (Err(e), _, _) => {
-                    println!("{}::{} x", test.module, test.name);
-                    println!("{}", e);
+                (Err(_), remaining_budget, _) => {
+                    let ExBudget { mem, cpu } = initial_budget - remaining_budget;
+
+                    println!(
+                        "    [FAIL] [mem: {}, cpu: {}] {}::{}",
+                        mem, cpu, test.module, test.name
+                    );
                 }
             }
         }
diff --git a/examples/sample/validators/swap.ak b/examples/sample/validators/swap.ak
index 8764f3b6..aedd877e 100644
--- a/examples/sample/validators/swap.ak
+++ b/examples/sample/validators/swap.ak
@@ -1,7 +1,7 @@
 use sample
 
 pub fn spend(datum: sample.Datum, rdmr: sample.Redeemer, _ctx: Nil) -> Bool {
-  let x = #(datum,  #[244])
+  let _x = #(datum, rdmr, #[244])
 
   let y = [#(#[222], #[222]), #(#[233], #[52])]
 

From db25ff38176c02a69afcfd24228027b21bba6d82 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 17:02:53 +0100
Subject: [PATCH 09/18] refactor: run_tests to avoid repetition.

---
 crates/project/src/lib.rs | 44 +++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 0138bc49..6a2670af 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -483,32 +483,32 @@ impl Project {
     }
 
     fn run_tests(&self, tests: Vec<Script>) {
+        // TODO: in the future we probably just want to be able to
+        // tell the machine to not explode on budget consumption.
+        let initial_budget = ExBudget {
+            mem: i64::MAX,
+            cpu: i64::MAX,
+        };
+
+        let fmt_tests = |is_passing: bool, test: Script, remaining_budget: ExBudget| -> String {
+            let ExBudget { mem, cpu } = initial_budget - remaining_budget;
+            format!(
+                "    [{}] [mem: {}, cpu: {}] {}::{}",
+                if is_passing { "PASS" } else { "FAIL" },
+                mem,
+                cpu,
+                test.module,
+                test.name
+            )
+        };
+
         for test in tests {
-            // TODO: in the future we probably just want to be able to
-            // tell the machine to not explode on budget consumption.
-            let initial_budget = ExBudget {
-                mem: i64::MAX,
-                cpu: i64::MAX,
-            };
-
-            let result = test.program.eval(initial_budget);
-
-            match result {
+            match test.program.eval(initial_budget) {
                 (Ok(..), remaining_budget, _) => {
-                    let ExBudget { mem, cpu } = initial_budget - remaining_budget;
-
-                    println!(
-                        "    [PASS] [mem: {}, cpu: {}] {}::{}",
-                        mem, cpu, test.module, test.name
-                    );
+                    println!("{}", fmt_tests(true, test, remaining_budget));
                 }
                 (Err(_), remaining_budget, _) => {
-                    let ExBudget { mem, cpu } = initial_budget - remaining_budget;
-
-                    println!(
-                        "    [FAIL] [mem: {}, cpu: {}] {}::{}",
-                        mem, cpu, test.module, test.name
-                    );
+                    println!("{}", fmt_tests(false, test, remaining_budget));
                 }
             }
         }

From 5770ea2456c92d9f765ad19730e6e0fbcc997656 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 17:16:41 +0100
Subject: [PATCH 10/18] Make test runner more sexy.

  Using colors.
---
 Cargo.lock                |  1 +
 crates/cli/src/lib.rs     |  4 ++--
 crates/project/Cargo.toml |  1 +
 crates/project/src/lib.rs | 14 +++++++++++++-
 4 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e49dff86..8674f1b7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -110,6 +110,7 @@ dependencies = [
  "hex",
  "ignore",
  "miette",
+ "owo-colors",
  "pallas",
  "pallas-traverse",
  "petgraph",
diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs
index d5789d46..a2fb3581 100644
--- a/crates/cli/src/lib.rs
+++ b/crates/cli/src/lib.rs
@@ -30,10 +30,10 @@ where
     if let Err(err) = build_result {
         err.report();
 
-        miette::bail!("failed: {} error(s), {warning_count} warning(s)", err.len(),);
+        miette::bail!("Failed: {} error(s), {warning_count} warning(s)", err.len(),);
     };
 
-    println!("\nfinished with {warning_count} warning(s)\n");
+    println!("\nFinished with {warning_count} warning(s)\n");
 
     Ok(())
 }
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 2f2188f5..42330a62 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -23,3 +23,4 @@ walkdir = "2.3.2"
 hex = "0.4.3"
 pallas = "0.14.0"
 pallas-traverse = "0.14.0"
+owo-colors = "3.5.0"
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 6a2670af..13828c4f 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -18,6 +18,7 @@ use aiken_lang::{
     IdGenerator,
 };
 use miette::NamedSource;
+use owo_colors::OwoColorize;
 use pallas::{
     codec::minicbor,
     ledger::{addresses::Address, primitives::babbage},
@@ -490,11 +491,22 @@ impl Project {
             cpu: i64::MAX,
         };
 
+        if !tests.is_empty() {
+            println!(
+                "\n{}\n",
+                "Running tests...".bold().underline().purple().to_string()
+            );
+        }
+
         let fmt_tests = |is_passing: bool, test: Script, remaining_budget: ExBudget| -> String {
             let ExBudget { mem, cpu } = initial_budget - remaining_budget;
             format!(
                 "    [{}] [mem: {}, cpu: {}] {}::{}",
-                if is_passing { "PASS" } else { "FAIL" },
+                if is_passing {
+                    "PASS".bold().green().to_string()
+                } else {
+                    "FAIL".bold().red().to_string()
+                },
                 mem,
                 cpu,
                 test.module,

From 2ba712eef69252941f27fd4c310b87fa8e922e5d Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 11:59:34 -0500
Subject: [PATCH 11/18] feat: start adding padding to test output

---
 crates/project/src/lib.rs           | 75 +++++++++++++++++++++--------
 examples/sample/lib/sample/thing.ak |  5 ++
 2 files changed, 61 insertions(+), 19 deletions(-)
 create mode 100644 examples/sample/lib/sample/thing.ak

diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 13828c4f..ad6ef79a 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -492,14 +492,45 @@ impl Project {
         };
 
         if !tests.is_empty() {
-            println!(
-                "\n{}\n",
-                "Running tests...".bold().underline().purple().to_string()
-            );
+            println!("\n{}\n", "Running tests...".bold().underline().purple());
         }
 
-        let fmt_tests = |is_passing: bool, test: Script, remaining_budget: ExBudget| -> String {
-            let ExBudget { mem, cpu } = initial_budget - remaining_budget;
+        let mut results = Vec::new();
+
+        for test in tests {
+            match test.program.eval(initial_budget) {
+                (Ok(..), remaining_budget, _) => {
+                    results.push((true, test, initial_budget - remaining_budget));
+                    // println!("{}", fmt_tests);
+                }
+                (Err(_), remaining_budget, _) => {
+                    results.push((false, test, initial_budget - remaining_budget));
+                    // println!("{}", fmt_tests());
+                }
+            }
+        }
+
+        let (max_mem, max_cpu) =
+            results
+                .iter()
+                .fold((0, 0), |(max_mem, max_cpu), (_, _, budget)| {
+                    if budget.mem >= max_mem && budget.cpu >= max_cpu {
+                        (budget.mem, budget.cpu)
+                    } else if budget.mem > max_mem {
+                        (budget.mem, max_cpu)
+                    } else if budget.cpu > max_cpu {
+                        (max_mem, budget.cpu)
+                    } else {
+                        (max_mem, max_cpu)
+                    }
+                });
+
+        let max_mem = max_mem.to_string().len() as i32;
+        let max_cpu = max_cpu.to_string().len() as i32;
+
+        let fmt_tests = |is_passing: bool, test: Script, spent_budget: ExBudget| -> String {
+            let ExBudget { mem, cpu } = spent_budget;
+
             format!(
                 "    [{}] [mem: {}, cpu: {}] {}::{}",
                 if is_passing {
@@ -507,22 +538,15 @@ impl Project {
                 } else {
                     "FAIL".bold().red().to_string()
                 },
-                mem,
-                cpu,
-                test.module,
-                test.name
+                padding_right(mem.to_string(), max_mem, " "),
+                padding_right(cpu.to_string(), max_cpu, " "),
+                test.module.blue(),
+                test.name.bright_blue()
             )
         };
 
-        for test in tests {
-            match test.program.eval(initial_budget) {
-                (Ok(..), remaining_budget, _) => {
-                    println!("{}", fmt_tests(true, test, remaining_budget));
-                }
-                (Err(_), remaining_budget, _) => {
-                    println!("{}", fmt_tests(false, test, remaining_budget));
-                }
-            }
+        for (is_passing, test, spent_budget) in results {
+            println!("{}", fmt_tests(is_passing, test, spent_budget))
         }
     }
 
@@ -682,3 +706,16 @@ fn is_aiken_path(path: &Path, dir: impl AsRef<Path>) -> bool {
             .expect("is_aiken_path(): to_str"),
     )
 }
+
+fn padding_right(text: String, n: i32, delimiter: &str) -> String {
+    let mut text = text.clone();
+    let diff = n - text.len() as i32;
+
+    if diff.is_positive() {
+        for _ in 0..diff {
+            text.push_str(delimiter);
+        }
+    }
+
+    text
+}
diff --git a/examples/sample/lib/sample/thing.ak b/examples/sample/lib/sample/thing.ak
new file mode 100644
index 00000000..503d6da2
--- /dev/null
+++ b/examples/sample/lib/sample/thing.ak
@@ -0,0 +1,5 @@
+use aiken/builtin
+
+test bar() {
+  builtin.length_of_bytearray(#[2, 2, 3]) == 3
+}

From 4cae4a446713d718c9e8183398acc04e095ad6e9 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 18:02:06 +0100
Subject: [PATCH 12/18] pad left instead of right, so units/thousands are
 aligned.

---
 crates/project/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index ad6ef79a..45c868ba 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -538,8 +538,8 @@ impl Project {
                 } else {
                     "FAIL".bold().red().to_string()
                 },
-                padding_right(mem.to_string(), max_mem, " "),
-                padding_right(cpu.to_string(), max_cpu, " "),
+                pad_left(mem.to_string(), max_mem, " "),
+                pad_left(cpu.to_string(), max_cpu, " "),
                 test.module.blue(),
                 test.name.bright_blue()
             )
@@ -707,13 +707,13 @@ fn is_aiken_path(path: &Path, dir: impl AsRef<Path>) -> bool {
     )
 }
 
-fn padding_right(text: String, n: i32, delimiter: &str) -> String {
+fn pad_left(text: String, n: i32, delimiter: &str) -> String {
     let mut text = text.clone();
     let diff = n - text.len() as i32;
 
     if diff.is_positive() {
         for _ in 0..diff {
-            text.push_str(delimiter);
+            text.insert_str(0, delimiter);
         }
     }
 

From 801ab3989e21d69842bfde218830e712e72372cd Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Thu, 8 Dec 2022 18:20:20 +0100
Subject: [PATCH 13/18] feat: display test runner summary alongside test
 results.

   Moar sexy.
---
 crates/project/src/lib.rs | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 45c868ba..cbbdb857 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -528,12 +528,11 @@ impl Project {
         let max_mem = max_mem.to_string().len() as i32;
         let max_cpu = max_cpu.to_string().len() as i32;
 
-        let fmt_tests = |is_passing: bool, test: Script, spent_budget: ExBudget| -> String {
+        let fmt_tests = |is_passing: &bool, test: &Script, spent_budget: &ExBudget| -> String {
             let ExBudget { mem, cpu } = spent_budget;
-
             format!(
                 "    [{}] [mem: {}, cpu: {}] {}::{}",
-                if is_passing {
+                if *is_passing {
                     "PASS".bold().green().to_string()
                 } else {
                     "FAIL".bold().red().to_string()
@@ -545,9 +544,31 @@ impl Project {
             )
         };
 
-        for (is_passing, test, spent_budget) in results {
+        for (is_passing, test, spent_budget) in &results {
             println!("{}", fmt_tests(is_passing, test, spent_budget))
         }
+
+        let (n_passed, n_failed) =
+            results
+                .iter()
+                .fold((0, 0), |(n_passed, n_failed), (is_passing, _, _)| {
+                    if *is_passing {
+                        (n_passed + 1, n_failed)
+                    } else {
+                        (n_passed, n_failed + 1)
+                    }
+                });
+
+        println!(
+            "{}",
+            format!(
+                "\n    Summary: {} test(s), {}; {}.",
+                results.len(),
+                format!("{} passed", n_passed).bright_green(),
+                format!("{} failed", n_failed).bright_red()
+            )
+            .bold()
+        )
     }
 
     fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {

From 4ad74bef1ff49750d8ce411530cb5bbdf927d93c Mon Sep 17 00:00:00 2001
From: rvcas <x@rvcas.dev>
Date: Thu, 8 Dec 2022 19:23:50 -0500
Subject: [PATCH 14/18] refactor: move prints to cli via EventListener trait

---
 Cargo.lock                      |   2 +-
 crates/cli/Cargo.toml           |   1 +
 crates/cli/src/lib.rs           | 112 ++++++++++++++++++++++++++++++--
 crates/project/Cargo.toml       |   1 -
 crates/project/src/lib.rs       | 112 +++++++++-----------------------
 crates/project/src/telemetry.rs |  19 ++++++
 6 files changed, 158 insertions(+), 89 deletions(-)
 create mode 100644 crates/project/src/telemetry.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8674f1b7..07455dc5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -59,6 +59,7 @@ dependencies = [
  "ignore",
  "indoc",
  "miette",
+ "owo-colors",
  "pallas-addresses",
  "pallas-codec",
  "pallas-crypto",
@@ -110,7 +111,6 @@ dependencies = [
  "hex",
  "ignore",
  "miette",
- "owo-colors",
  "pallas",
  "pallas-traverse",
  "petgraph",
diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml
index 11855d96..a6f9215c 100644
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -15,6 +15,7 @@ hex = "0.4.3"
 ignore = "0.4.18"
 indoc = "1.0"
 miette = { version = "5.3.0", features = ["fancy"] }
+owo-colors = "3.5.0"
 pallas-addresses = "0.14.0"
 pallas-codec = "0.14.0"
 pallas-crypto = "0.14.0"
diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs
index a2fb3581..985822c6 100644
--- a/crates/cli/src/lib.rs
+++ b/crates/cli/src/lib.rs
@@ -1,13 +1,19 @@
-pub mod cmd;
+use std::{env, path::PathBuf};
 
-use aiken_project::{config::Config, Project};
+use aiken_project::{
+    config::Config,
+    telemetry::{self, TestInfo},
+    Project,
+};
 use miette::IntoDiagnostic;
-use std::env;
-use std::path::PathBuf;
+use owo_colors::OwoColorize;
+use uplc::machine::cost_model::ExBudget;
+
+pub mod cmd;
 
 pub fn with_project<A>(directory: Option<PathBuf>, mut action: A) -> miette::Result<()>
 where
-    A: FnMut(&mut Project) -> Result<(), aiken_project::error::Error>,
+    A: FnMut(&mut Project<Terminal>) -> Result<(), aiken_project::error::Error>,
 {
     let project_path = if let Some(d) = directory {
         d
@@ -17,7 +23,7 @@ where
 
     let config = Config::load(project_path.clone()).into_diagnostic()?;
 
-    let mut project = Project::new(config, project_path);
+    let mut project = Project::new(config, project_path, Terminal::default());
 
     let build_result = action(&mut project);
 
@@ -37,3 +43,97 @@ where
 
     Ok(())
 }
+
+#[derive(Debug, Default, Clone, Copy)]
+pub struct Terminal;
+
+impl telemetry::EventListener for Terminal {
+    fn handle_event(&self, event: telemetry::Event) {
+        match event {
+            telemetry::Event::CompilingPackage { .. } => todo!(),
+            telemetry::Event::RunningTests => {
+                println!("\n{}\n", "Running tests...".bold().underline().purple());
+            }
+            telemetry::Event::FinishedTests { tests } => {
+                let (max_mem, max_cpu) = tests.iter().fold(
+                    (0, 0),
+                    |(max_mem, max_cpu), TestInfo { spent_budget, .. }| {
+                        if spent_budget.mem >= max_mem && spent_budget.cpu >= max_cpu {
+                            (spent_budget.mem, spent_budget.cpu)
+                        } else if spent_budget.mem > max_mem {
+                            (spent_budget.mem, max_cpu)
+                        } else if spent_budget.cpu > max_cpu {
+                            (max_mem, spent_budget.cpu)
+                        } else {
+                            (max_mem, max_cpu)
+                        }
+                    },
+                );
+
+                let max_mem = max_mem.to_string().len() as i32;
+                let max_cpu = max_cpu.to_string().len() as i32;
+
+                for test_info in &tests {
+                    println!("{}", fmt_test(test_info, max_mem, max_cpu))
+                }
+
+                let (n_passed, n_failed) =
+                    tests
+                        .iter()
+                        .fold((0, 0), |(n_passed, n_failed), test_info| {
+                            if test_info.is_passing {
+                                (n_passed + 1, n_failed)
+                            } else {
+                                (n_passed, n_failed + 1)
+                            }
+                        });
+
+                println!(
+                    "{}",
+                    format!(
+                        "\n    Summary: {} test(s), {}; {}.",
+                        tests.len(),
+                        format!("{} passed", n_passed).bright_green(),
+                        format!("{} failed", n_failed).bright_red()
+                    )
+                    .bold()
+                )
+            }
+        }
+    }
+}
+
+fn fmt_test(test_info: &TestInfo, max_mem: i32, max_cpu: i32) -> String {
+    let TestInfo {
+        is_passing,
+        test,
+        spent_budget,
+    } = test_info;
+
+    let ExBudget { mem, cpu } = spent_budget;
+
+    format!(
+        "    [{}] [mem: {}, cpu: {}] {}::{}",
+        if *is_passing {
+            "PASS".bold().green().to_string()
+        } else {
+            "FAIL".bold().red().to_string()
+        },
+        pad_left(mem.to_string(), max_mem, " "),
+        pad_left(cpu.to_string(), max_cpu, " "),
+        test.module.blue(),
+        test.name.bright_blue()
+    )
+}
+
+fn pad_left(mut text: String, n: i32, delimiter: &str) -> String {
+    let diff = n - text.len() as i32;
+
+    if diff.is_positive() {
+        for _ in 0..diff {
+            text.insert_str(0, delimiter);
+        }
+    }
+
+    text
+}
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 42330a62..2f2188f5 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -23,4 +23,3 @@ walkdir = "2.3.2"
 hex = "0.4.3"
 pallas = "0.14.0"
 pallas-traverse = "0.14.0"
-owo-colors = "3.5.0"
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index cbbdb857..1875047c 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -9,6 +9,7 @@ pub mod error;
 pub mod format;
 pub mod module;
 pub mod script;
+pub mod telemetry;
 
 use aiken_lang::{
     ast::{Definition, Function, ModuleKind, TypedFunction},
@@ -18,7 +19,6 @@ use aiken_lang::{
     IdGenerator,
 };
 use miette::NamedSource;
-use owo_colors::OwoColorize;
 use pallas::{
     codec::minicbor,
     ledger::{addresses::Address, primitives::babbage},
@@ -26,6 +26,7 @@ use pallas::{
 use pallas_traverse::ComputeHash;
 use script::Script;
 use serde_json::json;
+use telemetry::{EventListener, TestInfo};
 use uplc::{
     ast::{DeBruijn, Program},
     machine::cost_model::ExBudget,
@@ -35,6 +36,7 @@ use crate::{
     config::Config,
     error::{Error, Warning},
     module::{CheckedModule, CheckedModules, ParsedModule, ParsedModules},
+    telemetry::Event,
 };
 
 #[derive(Debug)]
@@ -51,7 +53,10 @@ pub const MINT: &str = "mint";
 pub const WITHDRAWL: &str = "withdrawl";
 pub const VALIDATOR_NAMES: [&str; 4] = [SPEND, CERT, MINT, WITHDRAWL];
 
-pub struct Project {
+pub struct Project<T>
+where
+    T: EventListener,
+{
     config: Config,
     defined_modules: HashMap<String, PathBuf>,
     id_gen: IdGenerator,
@@ -59,10 +64,14 @@ pub struct Project {
     root: PathBuf,
     sources: Vec<Source>,
     pub warnings: Vec<Warning>,
+    event_listener: T,
 }
 
-impl Project {
-    pub fn new(config: Config, root: PathBuf) -> Project {
+impl<T> Project<T>
+where
+    T: EventListener,
+{
+    pub fn new(config: Config, root: PathBuf, event_listener: T) -> Project<T> {
         let id_gen = IdGenerator::new();
 
         let mut module_types = HashMap::new();
@@ -78,6 +87,7 @@ impl Project {
             root,
             sources: vec![],
             warnings: vec![],
+            event_listener,
         }
     }
 
@@ -492,7 +502,7 @@ impl Project {
         };
 
         if !tests.is_empty() {
-            println!("\n{}\n", "Running tests...".bold().underline().purple());
+            self.event_listener.handle_event(Event::RunningTests);
         }
 
         let mut results = Vec::new();
@@ -500,75 +510,28 @@ impl Project {
         for test in tests {
             match test.program.eval(initial_budget) {
                 (Ok(..), remaining_budget, _) => {
-                    results.push((true, test, initial_budget - remaining_budget));
-                    // println!("{}", fmt_tests);
+                    let test_info = TestInfo {
+                        is_passing: true,
+                        test,
+                        spent_budget: initial_budget - remaining_budget,
+                    };
+
+                    results.push(test_info);
                 }
                 (Err(_), remaining_budget, _) => {
-                    results.push((false, test, initial_budget - remaining_budget));
-                    // println!("{}", fmt_tests());
+                    let test_info = TestInfo {
+                        is_passing: false,
+                        test,
+                        spent_budget: initial_budget - remaining_budget,
+                    };
+
+                    results.push(test_info);
                 }
             }
         }
 
-        let (max_mem, max_cpu) =
-            results
-                .iter()
-                .fold((0, 0), |(max_mem, max_cpu), (_, _, budget)| {
-                    if budget.mem >= max_mem && budget.cpu >= max_cpu {
-                        (budget.mem, budget.cpu)
-                    } else if budget.mem > max_mem {
-                        (budget.mem, max_cpu)
-                    } else if budget.cpu > max_cpu {
-                        (max_mem, budget.cpu)
-                    } else {
-                        (max_mem, max_cpu)
-                    }
-                });
-
-        let max_mem = max_mem.to_string().len() as i32;
-        let max_cpu = max_cpu.to_string().len() as i32;
-
-        let fmt_tests = |is_passing: &bool, test: &Script, spent_budget: &ExBudget| -> String {
-            let ExBudget { mem, cpu } = spent_budget;
-            format!(
-                "    [{}] [mem: {}, cpu: {}] {}::{}",
-                if *is_passing {
-                    "PASS".bold().green().to_string()
-                } else {
-                    "FAIL".bold().red().to_string()
-                },
-                pad_left(mem.to_string(), max_mem, " "),
-                pad_left(cpu.to_string(), max_cpu, " "),
-                test.module.blue(),
-                test.name.bright_blue()
-            )
-        };
-
-        for (is_passing, test, spent_budget) in &results {
-            println!("{}", fmt_tests(is_passing, test, spent_budget))
-        }
-
-        let (n_passed, n_failed) =
-            results
-                .iter()
-                .fold((0, 0), |(n_passed, n_failed), (is_passing, _, _)| {
-                    if *is_passing {
-                        (n_passed + 1, n_failed)
-                    } else {
-                        (n_passed, n_failed + 1)
-                    }
-                });
-
-        println!(
-            "{}",
-            format!(
-                "\n    Summary: {} test(s), {}; {}.",
-                results.len(),
-                format!("{} passed", n_passed).bright_green(),
-                format!("{} failed", n_failed).bright_red()
-            )
-            .bold()
-        )
+        self.event_listener
+            .handle_event(Event::FinishedTests { tests: results });
     }
 
     fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {
@@ -727,16 +690,3 @@ fn is_aiken_path(path: &Path, dir: impl AsRef<Path>) -> bool {
             .expect("is_aiken_path(): to_str"),
     )
 }
-
-fn pad_left(text: String, n: i32, delimiter: &str) -> String {
-    let mut text = text.clone();
-    let diff = n - text.len() as i32;
-
-    if diff.is_positive() {
-        for _ in 0..diff {
-            text.insert_str(0, delimiter);
-        }
-    }
-
-    text
-}
diff --git a/crates/project/src/telemetry.rs b/crates/project/src/telemetry.rs
new file mode 100644
index 00000000..4c4de6a9
--- /dev/null
+++ b/crates/project/src/telemetry.rs
@@ -0,0 +1,19 @@
+use uplc::machine::cost_model::ExBudget;
+
+use crate::script::Script;
+
+pub trait EventListener: std::fmt::Debug {
+    fn handle_event(&self, event: Event);
+}
+
+pub enum Event {
+    CompilingPackage { name: String },
+    RunningTests,
+    FinishedTests { tests: Vec<TestInfo> },
+}
+
+pub struct TestInfo {
+    pub is_passing: bool,
+    pub test: Script,
+    pub spent_budget: ExBudget,
+}

From d09d38d65b9289e0e8a103004780b03f8d3926b4 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Fri, 9 Dec 2022 14:14:15 +0100
Subject: [PATCH 15/18] Add a flag '--skip-tests' to the 'check' cmd.

  So that tests can be skipped, and the old behavior recovered if necessary.

  Tests execution is on by default however.
---
 crates/cli/src/cmd/check.rs | 13 +++++++++++--
 crates/project/src/lib.rs   |  5 ++---
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/crates/cli/src/cmd/check.rs b/crates/cli/src/cmd/check.rs
index 9f99e617..1bbc1126 100644
--- a/crates/cli/src/cmd/check.rs
+++ b/crates/cli/src/cmd/check.rs
@@ -6,8 +6,17 @@ pub struct Args {
     /// Path to project
     #[clap(short, long)]
     directory: Option<PathBuf>,
+
+    /// Skip tests; run only the type-checker
+    #[clap(short, long)]
+    skip_tests: bool,
 }
 
-pub fn exec(Args { directory }: Args) -> miette::Result<()> {
-    crate::with_project(directory, |p| p.check())
+pub fn exec(
+    Args {
+        directory,
+        skip_tests,
+    }: Args,
+) -> miette::Result<()> {
+    crate::with_project(directory, |p| p.check(skip_tests))
 }
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 1875047c..551564af 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -95,8 +95,8 @@ where
         self.compile(true, uplc, false)
     }
 
-    pub fn check(&mut self) -> Result<(), Error> {
-        self.compile(false, false, true)
+    pub fn check(&mut self, skip_tests: bool) -> Result<(), Error> {
+        self.compile(false, false, !skip_tests)
     }
 
     pub fn compile(
@@ -119,7 +119,6 @@ where
         // model the options differently to make it obvious at the type-level.
         if uplc_gen {
             let programs = self.code_gen(validators, &checked_modules)?;
-
             self.write_build_outputs(programs, uplc_dump)?;
         }
 

From a541018a56a6e85038acf4adf629a5b4cacca0ef Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Fri, 9 Dec 2022 14:29:13 +0100
Subject: [PATCH 16/18] Complete CHANGELOG about new test support.

---
 CHANGELOG.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 28657458..a86bd3af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,30 @@
 
 ## [next] - 2022-MM-DD
 
+### Added
+
+- **aiken-lang**: integrated unit tests
+
+  Aiken now supports writing unit tests directly in source files using the new
+  `test` keyword. Tests are functions with no arguments that are implicitly typed
+  to `bool`. For example:
+
+  ```gleam
+  test foo () {
+    1 + 1 == 2
+  }
+  ```
+
+- **aiken**: new `--skip-tests` flag for the `check` command
+
+### Changed
+
+- **aiken**: `check` now also runs and reports on any `test` found in the project
+
+### Removed
+
+N/A
+
 ## [v0.0.26] - 2022-11-23
 
 ### Added

From 749d8ecb10fce7219aa2a3511e797f8c0dc83d27 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Fri, 9 Dec 2022 14:35:50 +0100
Subject: [PATCH 17/18] Fix formatter to not prefix tests as 'pub'

---
 crates/lang/src/format.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/lang/src/format.rs b/crates/lang/src/format.rs
index 3dcc4775..2d5b7853 100644
--- a/crates/lang/src/format.rs
+++ b/crates/lang/src/format.rs
@@ -229,10 +229,9 @@ impl<'comments> Formatter<'comments> {
                 name,
                 arguments: args,
                 body,
-                public,
                 end_position,
                 ..
-            }) => self.definition_fn(public, "test", name, args, &None, body, *end_position),
+            }) => self.definition_fn(&false, "test", name, args, &None, body, *end_position),
 
             Definition::TypeAlias(TypeAlias {
                 alias,

From 0eb3cf221b4eceeef3e2b146a4ff1d795ac9b189 Mon Sep 17 00:00:00 2001
From: KtorZ <matthias.benkort@gmail.com>
Date: Fri, 9 Dec 2022 15:04:02 +0100
Subject: [PATCH 18/18] Trigger and report on more events in the compilation
 pipeline.

---
 crates/cli/src/lib.rs           | 29 +++++++++++++++++++++++++++--
 crates/project/src/lib.rs       | 22 +++++++++++++++++++---
 crates/project/src/telemetry.rs | 19 +++++++++++++++----
 3 files changed, 61 insertions(+), 9 deletions(-)

diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs
index 985822c6..0034bf3e 100644
--- a/crates/cli/src/lib.rs
+++ b/crates/cli/src/lib.rs
@@ -50,9 +50,34 @@ pub struct Terminal;
 impl telemetry::EventListener for Terminal {
     fn handle_event(&self, event: telemetry::Event) {
         match event {
-            telemetry::Event::CompilingPackage { .. } => todo!(),
+            telemetry::Event::StartingCompilation {
+                name,
+                version,
+                root,
+            } => {
+                println!(
+                    "{} {} {} ({})",
+                    "Compiling".bold().purple(),
+                    name.bold(),
+                    version,
+                    root.to_str().unwrap_or("").bright_blue()
+                );
+            }
+            telemetry::Event::ParsingProjectFiles => {
+                println!("{}", "...Parsing project files".bold().purple());
+            }
+            telemetry::Event::TypeChecking => {
+                println!("{}", "...Type-checking project".bold().purple());
+            }
+            telemetry::Event::GeneratingUPLC { output_path } => {
+                println!(
+                    "{} in {}",
+                    "...Generating Untyped Plutus Core".bold().purple(),
+                    output_path.to_str().unwrap_or("").bright_blue()
+                );
+            }
             telemetry::Event::RunningTests => {
-                println!("\n{}\n", "Running tests...".bold().underline().purple());
+                println!("{}\n", "...Running tests".bold().purple());
             }
             telemetry::Event::FinishedTests { tests } => {
                 let (max_mem, max_cpu) = tests.iter().fold(
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 551564af..59ce0be1 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -105,12 +105,23 @@ where
         uplc_dump: bool,
         run_tests: bool,
     ) -> Result<(), Error> {
+        self.event_listener
+            .handle_event(Event::StartingCompilation {
+                root: self.root.clone(),
+                name: self.config.name.clone(),
+                version: self.config.version.clone(),
+            });
+
+        self.event_listener.handle_event(Event::ParsingProjectFiles);
+
         self.read_source_files()?;
 
         let parsed_modules = self.parse_sources()?;
 
         let processing_sequence = parsed_modules.sequence()?;
 
+        self.event_listener.handle_event(Event::TypeChecking);
+
         let mut checked_modules = self.type_check(parsed_modules, processing_sequence)?;
 
         let validators = self.validate_validators(&mut checked_modules)?;
@@ -118,6 +129,9 @@ where
         // TODO: In principle, uplc_gen and run_tests can't be true together. We probably want to
         // model the options differently to make it obvious at the type-level.
         if uplc_gen {
+            self.event_listener.handle_event(Event::GeneratingUPLC {
+                output_path: self.output_path(),
+            });
             let programs = self.code_gen(validators, &checked_modules)?;
             self.write_build_outputs(programs, uplc_dump)?;
         }
@@ -533,11 +547,13 @@ where
             .handle_event(Event::FinishedTests { tests: results });
     }
 
-    fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {
-        let assets = self.root.join("assets");
+    fn output_path(&self) -> PathBuf {
+        self.root.join("assets")
+    }
 
+    fn write_build_outputs(&self, programs: Vec<Script>, uplc_dump: bool) -> Result<(), Error> {
         for script in programs {
-            let script_output_dir = assets.join(script.module).join(script.name);
+            let script_output_dir = self.output_path().join(script.module).join(script.name);
 
             fs::create_dir_all(&script_output_dir)?;
 
diff --git a/crates/project/src/telemetry.rs b/crates/project/src/telemetry.rs
index 4c4de6a9..4bc8da61 100644
--- a/crates/project/src/telemetry.rs
+++ b/crates/project/src/telemetry.rs
@@ -1,15 +1,26 @@
-use uplc::machine::cost_model::ExBudget;
-
 use crate::script::Script;
+use std::path::PathBuf;
+use uplc::machine::cost_model::ExBudget;
 
 pub trait EventListener: std::fmt::Debug {
     fn handle_event(&self, event: Event);
 }
 
 pub enum Event {
-    CompilingPackage { name: String },
+    StartingCompilation {
+        name: String,
+        version: String,
+        root: PathBuf,
+    },
+    ParsingProjectFiles,
+    TypeChecking,
+    GeneratingUPLC {
+        output_path: PathBuf,
+    },
     RunningTests,
-    FinishedTests { tests: Vec<TestInfo> },
+    FinishedTests {
+        tests: Vec<TestInfo>,
+    },
 }
 
 pub struct TestInfo {