bytevm 0.7.1

A tiny bytecode virtual machine
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use bytevm::prelude::*;

#[test]
fn test_create_array() {

    let mut program = Program::builder();

    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create an array with 3 elements
                .push_integer(1)
                .push_integer(2)
                .push_integer(3)
                .create_array(3)

                // Return the array
                .return_value()
        )
        .build()
    );

    let mut vm = Vm::default();
    vm.load_program(program.build());
    let result = vm.run(None, None).unwrap().result.unwrap();

    match result {
        Variant::Array(array) => {
            assert_eq!(array.borrow().len(), 3);
            assert_eq!(array.borrow().get(0), Some(&Variant::Integer(1)));
            assert_eq!(array.borrow().get(1), Some(&Variant::Integer(2)));
            assert_eq!(array.borrow().get(2), Some(&Variant::Integer(3)));
        }
        _ => panic!("Expected array")
    }
}

#[test]
fn test_get_array_element() {

    let mut program = Program::builder();
    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create an array with 3 elements
                .push_integer(1)
                .push_integer(2)
                .push_integer(3)
                .create_array(3)

                // Return the second element
                .push_index(1)
                .get_array_item()
                .return_value()
        )
        .build()
    );

    let mut vm = Vm::default();
    vm.load_program(program.build());
    let result = vm.run(None, None).unwrap().result.unwrap();
    assert_eq!(result, Variant::Integer(2));
}

#[test]
fn test_set_array_element() {

    let mut program = Program::builder();

    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create an array with 3 elements
                .push_integer(1)
                .push_integer(2)
                .push_integer(3)
                .create_array(3)

                // Set the second element to 4
                .push_index(1)
                .push_integer(4)
                .set_array_item()

                // Return the second element
                .push_index(1)
                .get_array_item()
                .return_value()
        )
        .build()
    );

    let mut vm = Vm::default();
    vm.load_program(program.build());
    let result = vm.run(None, None).unwrap().result.unwrap();
    assert_eq!(result, Variant::Integer(4));
}

#[test]
fn test_get_array_length() {
    let mut program = Program::builder();
    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create an array with 3 elements
                .push_integer(1)
                .push_integer(2)
                .push_integer(3)
                .create_array(3)

                // Get the length of the array
                .get_array_length()
                .return_value()
        )
        .build()
    );

    let mut vm = Vm::default();
    vm.load_program(program.build());
    let result = vm.run(None, None).unwrap().result.unwrap();
    assert_eq!(result, Variant::Integer(3));
}