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

use bytevm::prelude::*;

#[test]
fn test_create_dictionary() {

    let key1 = String::from("key1");
    let key2 = 4;
    let key3 = true;

    let mut program = Program::builder();
    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create a dictionary with 3 key-value pairs
                .push_string(key1.clone())
                .push_integer(1)
                .push_integer(key2)
                .push_integer(2)
                .push_boolean(key3)
                .push_integer(3)
                .create_dictionary(3)

                // Return the dictionary
                .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::Dictionary(array) => {
            assert_eq!(array.borrow().len(), 3);
            assert_eq!(array.borrow().get(&Variant::String(key1)), Some(&Variant::Integer(1)));
            assert_eq!(array.borrow().get(&Variant::Integer(key2)), Some(&Variant::Integer(2)));
            assert_eq!(array.borrow().get(&Variant::Boolean(key3)), Some(&Variant::Integer(3)));
        }
        _ => panic!("Expected table")
    }
}

#[test]
fn test_get_dictionary_item() {

    let key1 = String::from("key1");
    let key2 = String::from("key2");
    let key3 = String::from("key3");

    let mut program = Program::builder();
    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create a dictionary with 3 key-value pairs
                .push_string(key1.clone())
                .push_integer(1)
                .push_string(key2.clone())
                .push_integer(2)
                .push_string(key3.clone())
                .push_integer(3)
                .create_dictionary(3)

                // Get the value for key1
                .push_string(key1)
                .get_dictionary_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(1));
}

#[test]
fn test_get_dictionary_keys() {

    let key1 = String::from("key1");
    let key2 = String::from("key2");
    let key3 = String::from("key3");

    let mut program = Program::builder();
    program.add_function(FunctionBuilder::default()
        .name("main")
        .arity(1)
        .body(
            BlockEncoder::default()
                // Create a dictionary with 3 key-value pairs
                .push_string(key1.clone())
                .push_integer(1)
                .push_string(key2.clone())
                .push_integer(2)
                .push_string(key3.clone())
                .push_integer(3)
                .create_dictionary(3)

                // Get the keys of the dictionary
                .get_dictionary_keys()
                .return_value()
        )
        .build()
    );

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

    // find key1 in result
    match result {
        Variant::Array(array) => {
            assert_eq!(array.borrow().len(), 3);
            assert!(array.borrow().contains(&Variant::String(key1)));
            assert!(array.borrow().contains(&Variant::String(key2)));
            assert!(array.borrow().contains(&Variant::String(key3)));
        }
        _ => panic!("Expected array")
    }

}