msgpack-rs 0.0.1

rust implementation of msgpack
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

use msgpack::{self, de};
use serde::Deserialize;

#[test]
fn de_bool() {
    let buf = [0xc3, 0xc2];
    let mut de = de::Deserializer::new(&buf[..]);

    assert_eq!(true, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(false, Deserialize::deserialize(&mut de).unwrap());
}

#[test]
fn de_option() {
    let buf = [0xc0, 0x01];
    let mut de = de::Deserializer::new(&buf[..]);

    let expect1: Option<u8> = None;
    let expect2: Option<u8> = Some(1);

    assert_eq!(expect1, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(expect2, Deserialize::deserialize(&mut de).unwrap());
}

#[test]
fn de_u8() {
    let buf = [
        0x01, // 1
        0x7f, // 127
        0xcc, 0x80, // 128
        0xcc, 0xff, // 255
    ];
    let mut de = de::Deserializer::new(&buf[..]);

    assert_eq!(1 as u8, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(127 as u8, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(128 as u8, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(255 as u8, Deserialize::deserialize(&mut de).unwrap());
}

#[test]
fn de_u32() {
    let buf = [
        0xce, 0x00, 0x01, 0x00, 0x00, // 65536
        0xce, 0xff, 0xff, 0xff, 0xff, // 4294967295
    ];
    let mut de = de::Deserializer::new(&buf[..]);

    assert_eq!(65536 as u32, Deserialize::deserialize(&mut de).unwrap());
    assert_eq!(
        4294967295 as u32,
        Deserialize::deserialize(&mut de).unwrap()
    );
}

#[test]
fn unpack_seq() {
    let buf = [0x92, 0x01, 0x02];
    let mut de = de::Deserializer::new(&buf[..]);
    let v2: Vec<u8> = Deserialize::deserialize(&mut de).unwrap();
    assert_eq!(vec![1, 2], v2);
}

#[test]
fn unpack_tuple() {
    let buf = [0x92, 0x01, 0x02];
    let mut de = de::Deserializer::new(&buf[..]);
    let ret: (u8, u8) = Deserialize::deserialize(&mut de).unwrap();
    assert_eq!((1, 2), ret);
}

#[test]
fn unpack_string() {
    let buf = [0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f];
    let mut de = de::Deserializer::new(&buf[..]);
    let ret: String = Deserialize::deserialize(&mut de).unwrap();
    assert_eq!("hello".to_string(), ret);
}

#[test]
fn unpack_str() {
    use std::borrow::Cow;

    let buf = [0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f];
    let mut de = de::Deserializer::new(&buf[..]);
    let ret: Cow<str> = Deserialize::deserialize(&mut de).unwrap();
    assert_eq!(Cow::from("hello"), ret);
}

#[derive(Deserialize, Debug, PartialEq)]
struct Point {
    h: u8,
    o: String,
}

#[test]
fn unpack_struct() {
    let buf = [0x82, 0xa1, 0x68, 0x01, 0xa1, 0x6f, 0xa1, 0x6f];
    let mut de = de::Deserializer::new(&buf[..]);
    let ret: Point = Deserialize::deserialize(&mut de).unwrap();
    assert_eq!(
        Point {
            o: "o".to_string(),
            h: 1,
        },
        ret
    );
}