rust_dynamic 0.48.0

Support for dynamically-typed values in run-time
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

#[cfg(test)]
mod tests {
    #![allow(unused_imports)]
    use super::*;
    use rust_dynamic::value::Value;

    #[test]
    fn test_serialize_bin_int() {
        let data = Value::from(42 as i64).unwrap();
        let bin_out = data.to_binary().unwrap();
        assert_ne!(bin_out.len(), 0);
    }
    #[test]
    fn test_serialize_deserialize_bin_int() {
        let data = Value::from(42 as i64).unwrap();
        let bin_out = data.to_binary().unwrap();
        let data2 = Value::from_binary(bin_out).unwrap();
        assert_eq!(data2.cast_int().unwrap(), 42 as i64);
    }
    #[test]
    fn test_serialize_wrap_int() {
        let data = Value::from(42 as i64).unwrap();
        let bin_data = data.wrap().unwrap();
        assert_eq!(bin_data.len(), 79);
    }
    #[test]
    fn test_serialize_unwrap_int() {
        let data = Value::from(42 as i64).unwrap();
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_eq!(data2.cast_int().unwrap(), 42);
    }
    #[test]
    fn test_serialize_unwrap_json1() {
        let data = Value::json(serde_json::json!(42));
        let bin_data = data.wrap().unwrap();
        let data2: Value = bin_data.unwrap().unwrap();
        let data3 = data2.cast_json_to_value().unwrap();
        assert_eq!(data3.cast_int().unwrap(), 42);
    }
    #[test]
    fn test_serialize_unwrap_dict() {
        let data = Value::dict();
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_eq!(data2.len(), 0);
    }
    #[test]
    fn test_serialize_unwrap_list() {
        let data = Value::list();
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_eq!(data2.len(), 0);
    }
    #[test]
    fn test_serialize_operator1() {
        let data = Value::operator(42, Value::from(42 as i64).unwrap(), Value::none());
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_eq!(data2.type_name(), "Operator");
    }
    #[test]
    fn test_serialize_operator2() {
        let data = Value::operator(42, Value::from(42 as i64).unwrap(), Value::none());
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_eq!(data2.cast_operator_opcode().unwrap(), 42 as i32);
    }
    #[test]
    fn test_serialize_operator3() {
        let data = Value::operator(42, Value::from(42 as i64).unwrap(), Value::none());
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        let opval = data2.cast_operator_value().unwrap();
        assert_eq!(opval.cast_int().unwrap(), 42 as i64);
    }
    #[test]
    fn test_serialize_operator4() {
        let mut data = Value::list();
        let data1 = Value::operator(42, Value::from(42 as i64).unwrap(), Value::none());
        data = data.push(data1);
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        assert_ne!(data2.len(), 0);
    }
    #[test]
    fn test_serialize_operator5() {
        let mut data = Value::list();
        let data1 = Value::operator(42, Value::from(42 as i64).unwrap(), Value::none());
        data = data.push(data1);
        let bin_data = data.wrap().unwrap();
        let data2 = bin_data.unwrap().unwrap();
        let op_object = data2.cast_list().unwrap();
        let opval = op_object[0].cast_operator_value().unwrap();
        assert_eq!(opval.cast_int().unwrap(), 42 as i64);
    }
    #[test]
    fn test_serialize_lambda() {
        let data = Value::lambda()
                        .push(Value::operator(42, Value::from(42 as i64).unwrap(), Value::none()))
                        .push(Value::operator(43, Value::from(43 as i64).unwrap(), Value::none()));

        let buffer = data.compile().unwrap();
        assert_ne!(buffer.len(), 0);
    }
}