mun_runtime 0.4.0

A runtime for hot reloading and invoking Mun from 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
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

use itertools::Itertools;
use mun_runtime::{ArrayRef, StructRef};
use mun_test::CompileAndRunTestDriver;

#[test]
fn arrays() {
    let driver = CompileAndRunTestDriver::new(
        r"
    pub fn main() -> [i32] { [5,4,3,2,1] }
    ",
        |builder| builder,
    )
    .expect("Failed to build test driver");

    let result: ArrayRef<'_, i32> = driver.runtime.invoke("main", ()).unwrap();

    assert_eq!(result.len(), 5);
    assert!(result.capacity() >= 5);
    assert_eq!(result.iter().collect::<Vec<_>>(), vec![5, 4, 3, 2, 1]);
}

#[test]
fn array_of_structs() {
    let driver = CompileAndRunTestDriver::new(
        r"
    pub struct Number { value: i32 };
    pub struct(value) Value { value: i64, other: i64 };

    pub fn main() -> [Number] { [Number { value: 2351 }, Number { value: 18571 }] }
    pub fn main_value() -> [Value] { [Value { value: 253, other: 1823512 }, Value { value: 123, other: 436501 }] }
    ",
        |builder| builder,
    )
    .expect("Failed to build test driver");

    let result: ArrayRef<'_, StructRef> = driver.runtime.invoke("main", ()).unwrap();
    let number: i32 = result.iter().nth(1).unwrap().get("value").unwrap();

    assert_eq!(result.len(), 2);
    assert_eq!(number, 18571);

    let result: ArrayRef<'_, StructRef> = driver.runtime.invoke("main_value", ()).unwrap();
    let number: i64 = result.iter().nth(1).unwrap().get("value").unwrap();

    assert_eq!(result.len(), 2);
    assert_eq!(number, 123);
}

#[test]
fn arrays_as_argument() {
    let driver = CompileAndRunTestDriver::new(
        r"
    pub fn generate() -> [i32] { [5,4,3,2,1] }
    pub fn add_one(array: [i32], len: usize) -> [i32] {
        let i = 0;
        loop {
            array[i] += 1;
            i += 1;
            if i >= len {
                break array
            }
        }
    }
    ",
        |builder| builder,
    )
    .expect("Failed to build test driver");

    let result: ArrayRef<'_, i32> = driver.runtime.invoke("generate", ()).unwrap();

    assert_eq!(result.len(), 5);
    assert!(result.capacity() >= 5);
    assert_eq!(result.iter().collect::<Vec<_>>(), vec![5, 4, 3, 2, 1]);

    let result_array: ArrayRef<'_, i32> = driver
        .runtime
        .invoke("add_one", (result.clone(), result.len()))
        .unwrap();

    assert_eq!(result_array.len(), 5);
    assert!(result_array.capacity() >= 5);
    assert_eq!(result_array.iter().collect::<Vec<_>>(), vec![6, 5, 4, 3, 2]);
}

#[test]
fn root_array() {
    let driver = CompileAndRunTestDriver::new(
        r"
    pub fn main() -> [i32] { [5,4,3,2,1] }
    ",
        |builder| builder,
    )
    .expect("Failed to build test driver");

    let result = {
        let array: ArrayRef<i32> = driver.runtime.invoke("main", ()).unwrap();
        array.root()
    };

    let result = result.as_ref(&driver.runtime);
    assert_eq!(result.len(), 5);
    assert!(result.capacity() >= 5);
    assert_eq!(result.iter().collect::<Vec<_>>(), vec![5, 4, 3, 2, 1]);
}

#[test]
fn construct_array_simple() {
    let driver =
        CompileAndRunTestDriver::new(r"", |builder| builder).expect("Failed to build test driver");

    let test_data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 147294028];
    let array = driver.runtime.construct_array(test_data.iter().copied());
    assert!(array.capacity() >= test_data.len());
    assert_eq!(array.len(), test_data.len());
    assert_eq!(array.iter().collect_vec(), test_data);
}