[go: up one dir, main page]

rmp 0.7.4

Pure Rust MessagePack serialization implementation
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

extern crate rmp;

use rmp::Value;
use rmp::value::{Float, Integer};

#[test]
fn display_nil() {
    assert_eq!("nil", format!("{}", Value::Nil));
}

#[test]
fn display_bool() {
    assert_eq!("true", format!("{}", Value::Boolean(true)));
    assert_eq!("false", format!("{}", Value::Boolean(false)));
}

#[test]
fn display_int() {
    assert_eq!("42", format!("{}", Value::Integer(Integer::U64(42))));
    assert_eq!("42", format!("{}", Value::Integer(Integer::I64(42))));
}

#[test]
fn display_float() {
    assert_eq!("3.1415", format!("{}", Value::Float(Float::F32(3.1415))));
    assert_eq!("3.1415", format!("{}", Value::Float(Float::F64(3.1415))));
}

#[test]
fn display_string() {
    assert_eq!("\"le string\"", format!("{}", Value::String("le string".to_owned())));
}

#[test]
fn display_binary() {
    assert_eq!("[108, 101, 32, 115, 116, 114, 105, 110, 103]", format!("{}",
        Value::Binary(b"le string".to_vec())));
}

#[test]
fn display_array() {
    assert_eq!("[]", format!("{}", Value::Array(vec![])));
    assert_eq!("[nil]", format!("{}", Value::Array(vec![Value::Nil])));
    assert_eq!("[nil, nil]", format!("{}", Value::Array(vec![Value::Nil, Value::Nil])));
}

#[test]
fn display_map() {
    assert_eq!("{}", format!("{}", Value::Map(vec![])));
    assert_eq!("{nil: nil}", format!("{}", Value::Map(vec![(Value::Nil, Value::Nil)])));
    assert_eq!("{nil: nil, true: false}", format!("{}", Value::Map(vec![(Value::Nil, Value::Nil),
        (Value::Boolean(true), Value::Boolean(false))])));
}

#[test]
fn display_ext() {
    assert_eq!("[1, []]", format!("{}", Value::Ext(1, vec![])));
    assert_eq!("[1, [100]]", format!("{}", Value::Ext(1, vec![100])));
    assert_eq!("[1, [100, 42]]", format!("{}", Value::Ext(1, vec![100, 42])));
}

#[test]
fn from_bool() {
    assert_eq!(Value::Boolean(true), Value::from(true));
    assert_eq!(Value::Boolean(false), Value::from(false));
}

#[test]
fn from_u8() {
    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u8));
}

#[test]
fn from_u16() {
    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u16));
}

#[test]
fn from_u32() {
    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u32));
}

#[test]
fn from_u64() {
    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42u64));
}

#[test]
fn from_usize() {
    assert_eq!(Value::Integer(Integer::U64(42)), Value::from(42usize));
}

#[test]
fn from_i8() {
    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i8));
}

#[test]
fn from_i16() {
    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i16));
}

#[test]
fn from_i32() {
    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i32));
}

#[test]
fn from_i64() {
    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42i64));
}

#[test]
fn from_isize() {
    assert_eq!(Value::Integer(Integer::I64(-42)), Value::from(-42isize));
}

#[test]
fn from_f32() {
    assert_eq!(Value::Float(Float::F32(3.1415)), Value::from(3.1415f32));
}

#[test]
fn from_f64() {
    assert_eq!(Value::Float(Float::F64(3.1415)), Value::from(3.1415f64));
}