rscel 1.0.8

Cel interpreter in rust
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

mod interp;
mod types;

pub use interp::Interpreter;
pub use types::*;

#[cfg(test)]
mod test {
    use crate::{types::CelByteCode, CelValue};

    use super::{
        types::{ByteCode, JmpWhen},
        Interpreter,
    };
    use test_case::test_case;

    #[test_case(ByteCode::Add, 7.into())]
    #[test_case(ByteCode::Sub, 1.into())]
    #[test_case(ByteCode::Mul, 12.into())]
    #[test_case(ByteCode::Div, 1.into())]
    #[test_case(ByteCode::Mod, 1.into())]
    #[test_case(ByteCode::Lt, false.into())]
    #[test_case(ByteCode::Le, false.into())]
    #[test_case(ByteCode::Eq, false.into())]
    #[test_case(ByteCode::Ne, true.into())]
    #[test_case(ByteCode::Ge, true.into())]
    #[test_case(ByteCode::Gt, true.into())]
    fn test_interp_ops(op: ByteCode, expected: CelValue) {
        let mut prog =
            CelByteCode::from_vec(vec![ByteCode::Push(4.into()), ByteCode::Push(3.into())]);
        prog.push(op);
        let interp = Interpreter::empty();

        assert!(interp.run_raw(&prog, true).unwrap() == expected);
    }

    #[test]
    fn test_backward_jump_loop_executes() {
        let prog = CelByteCode::from_vec(vec![
            ByteCode::Push(0.into()),
            ByteCode::Dup,
            ByteCode::Push(2.into()),
            ByteCode::Lt,
            ByteCode::JmpCond {
                when: JmpWhen::False,
                dist: 3,
            },
            ByteCode::Push(1.into()),
            ByteCode::Add,
            ByteCode::Jmp(-7),
        ]);

        let interp = Interpreter::empty();
        let result = interp.run_raw(&prog, true).unwrap();

        assert_eq!(result, 2.into());
    }
}