roto 0.10.0

a statically-typed, compiled, embedded scripting language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use super::{Module, TypedFunc};
use crate::{runtime::OptCtx, value::Verdict};

pub struct TestCase<Ctx: 'static> {
    name: String,
    func: TypedFunc<Ctx, fn() -> Verdict<(), ()>>,
}

impl<C: OptCtx> TestCase<C> {
    pub fn new(
        name: String,
        func: TypedFunc<C, fn() -> Verdict<(), ()>>,
    ) -> Self {
        Self { name, func }
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

impl<C: OptCtx> TestCase<C> {
    pub fn run(&self, ctx: &mut C::Ctx) -> Result<(), ()> {
        match self.func.call_tuple(ctx, ()) {
            Verdict::Accept(()) => Ok(()),
            Verdict::Reject(()) => Err(()),
        }
    }
}

pub(crate) fn get_tests<Ctx: OptCtx>(
    module: &mut Module<Ctx>,
) -> impl Iterator<Item = TestCase<Ctx>> + use<'_, Ctx> {
    let mut tests: Vec<_> = module
        .functions
        .keys()
        .filter(|x| {
            x.rsplit_once(".")
                .map_or(x.as_ref(), |x| x.1)
                .starts_with("test#")
        })
        .map(Clone::clone)
        .collect();

    tests.sort();

    tests.into_iter().map(|name| {
        TestCase::new(
            name.replace("test#", ""),
            module
                .get_function::<fn() -> Verdict<(), ()>>(
                    name.strip_prefix("pkg.").unwrap(),
                )
                .unwrap(),
        )
    })
}

pub(crate) fn run_tests<Ctx: OptCtx>(
    module: &mut Module<Ctx>,
    mut ctx: Ctx,
) -> Result<(), ()> {
    let tests: Vec<_> = get_tests::<Ctx>(module).collect();

    let total = tests.len();
    let total_width = total.to_string().len();
    let mut successes = 0;
    let mut failures = 0;

    for (n, test) in tests.into_iter().enumerate() {
        let n = n + 1;
        let test_display = test.name();
        print!("Test {n:>total_width$} / {total}: {test_display}... ");

        if test.run(ctx.get_context()) == Ok(()) {
            successes += 1;
            println!("\x1B[92mok\x1B[m");
        } else {
            failures += 1;
            println!("\x1B[91mfail\x1B[m");
        }
    }
    println!("Ran {total} tests, {successes} succeeded, {failures} failed");

    if failures == 0 {
        Result::Ok(())
    } else {
        Result::Err(())
    }
}