essential-constraint-vm 0.6.0

The Essential constraint checking VM
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::{
    asm,
    error::{OpError, TotalControlFlowError},
    exec_ops,
    test_util::test_access,
};

#[test]
fn test_jump_if() {
    let access = *test_access();
    let ops = &[
        asm::Stack::Push(1).into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(3).into(),
        asm::Stack::Push(1).into(),
        asm::TotalControlFlow::JumpForwardIf.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
    ];
    let stack = exec_ops(ops, access).unwrap();
    assert_eq!(&stack[..], &[3]);

    let ops = &[
        asm::Stack::Push(1).into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(3).into(),
        asm::Stack::Push(0).into(),
        asm::TotalControlFlow::JumpForwardIf.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
    ];
    let stack = exec_ops(ops, access).unwrap();
    assert_eq!(&stack[..], &[4]);
}

#[test]
fn test_halt_if() {
    let access = *test_access();
    let ops = &[
        asm::Stack::Push(1).into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(1).into(),
        asm::TotalControlFlow::HaltIf.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
    ];
    let stack = exec_ops(ops, access).unwrap();
    assert_eq!(&stack[..], &[2]);

    let ops = &[
        asm::Stack::Push(1).into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
        asm::Stack::Push(0).into(),
        asm::TotalControlFlow::HaltIf.into(),
        asm::Stack::Push(1).into(),
        asm::Alu::Add.into(),
    ];
    let stack = exec_ops(ops, access).unwrap();
    assert_eq!(&stack[..], &[3]);
}

#[test]
fn test_panic_if() {
    let mut stack = crate::Stack::default();
    stack.push(42).unwrap();
    stack.push(43).unwrap();
    stack.push(1).unwrap();

    let err = super::panic_if(&mut stack).unwrap_err();
    assert!(err.to_string().ends_with("[42, 43]"),);
    assert!(
        matches!(err, OpError::TotalControlFlow(TotalControlFlowError::Panic(s)) if s == vec![42, 43])
    );

    let mut stack = crate::Stack::default();
    stack.push(1).unwrap();

    let err = super::panic_if(&mut stack).unwrap_err();
    assert!(err.to_string().ends_with("[]"),);
    assert!(
        matches!(err, OpError::TotalControlFlow(TotalControlFlowError::Panic(s)) if s.is_empty())
    );

    let mut stack = crate::Stack::default();
    stack.push(42).unwrap();
    stack.push(43).unwrap();
    stack.push(0).unwrap();

    super::panic_if(&mut stack).unwrap();
    assert_eq!(stack.len(), 2);
    assert_eq!(stack.pop().unwrap(), 43);
    assert_eq!(stack.pop().unwrap(), 42);

    let mut stack = crate::Stack::default();
    stack.push(42).unwrap();
    stack.push(43).unwrap();
    let err = super::panic_if(&mut stack).unwrap_err();
    assert!(matches!(
        err,
        OpError::TotalControlFlow(TotalControlFlowError::InvalidPanicIfCondition)
    ));
}