extism-convert 1.21.0

Traits to make Rust types usable with Extism
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

use crate::*;

#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
struct Testing {
    a: String,
    b: i64,
    c: f32,
}

#[test]
fn roundtrip_json() {
    let x = Testing {
        a: "foobar".to_string(),
        b: 123,
        c: 456.7,
    };
    let bytes = Json(&x).to_bytes().unwrap();
    let Json(y): Json<Testing> = FromBytes::from_bytes(&bytes).unwrap();
    assert_eq!(x, y);
}

#[test]
#[cfg(feature = "msgpack")]
fn roundtrip_msgpack() {
    let x = Testing {
        a: "foobar".to_string(),
        b: 123,
        c: 456.7,
    };
    let bytes = Msgpack(&x).to_bytes().unwrap();
    let Msgpack(y): Msgpack<Testing> = FromBytes::from_bytes(&bytes).unwrap();
    assert_eq!(x, y);
}

#[test]
fn roundtrip_base64() {
    let bytes = Base64("this is a test").to_bytes().unwrap();
    let Base64(s): Base64<String> = FromBytes::from_bytes(bytes.as_bytes()).unwrap();
    assert_eq!(s, "this is a test");
}

#[test]
fn rountrip_option() {
    // `None` case
    let e0: Option<Json<Testing>> = FromBytes::from_bytes(&[]).unwrap();
    let b = e0.to_bytes().unwrap();
    let e1: Option<Json<Testing>> = FromBytes::from_bytes(&b).unwrap();
    assert!(e0.is_none());
    assert_eq!(e0.is_none(), e1.is_none());

    // `Some` case
    let x = Testing {
        a: "foobar".to_string(),
        b: 123,
        c: 456.7,
    };
    let bytes = Json(&x).to_bytes().unwrap();
    let y: Option<Json<Testing>> = FromBytes::from_bytes(&bytes).unwrap();
    let b = ToBytes::to_bytes(&y).unwrap();
    let z: Option<Json<Testing>> = FromBytes::from_bytes(&b).unwrap();
    assert_eq!(y.unwrap().0, z.unwrap().0);
}

#[test]
fn check_bool() {
    // `None` case
    let a = true.to_bytes().unwrap();
    let b = false.to_bytes().unwrap();
    assert_ne!(a, b);

    assert_eq!(a, [1]);
    assert_eq!(b, [0]);
}

#[cfg(all(feature = "raw", target_endian = "little"))]
mod raw_tests {
    use crate::*;

    #[test]
    fn test_raw() {
        #[derive(Debug, Clone, Copy, PartialEq)]
        struct TestRaw {
            a: i32,
            b: f64,
            c: bool,
        }
        unsafe impl bytemuck::Pod for TestRaw {}
        unsafe impl bytemuck::Zeroable for TestRaw {}
        let x = TestRaw {
            a: 123,
            b: 45678.91011,
            c: true,
        };
        let raw = Raw(&x).to_bytes().unwrap();
        let y = Raw::from_bytes(raw).unwrap();
        assert_eq!(&x, y.0);

        let y: Result<Raw<[u8; std::mem::size_of::<TestRaw>()]>, Error> = Raw::from_bytes(raw);
        assert!(y.is_ok());
    }
}