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
pub use value::{Value, Binary};
pub use message::Message;
pub use array::Array;
pub use message_id::MessageId;
mod macros;
pub mod value;
pub mod message;
pub mod array;
pub mod encode;
pub mod decode;
pub mod serde_impl;
pub mod spec;
mod json;
pub mod message_id;
pub const MAX_NSON_SIZE: u32 = 64 * 1024 * 1024;
pub const MIN_NSON_SIZE: u32 = 4 + 1;
#[cfg(test)]
mod tests {
use crate::message_id::MessageId;
use serde::{Serialize, Deserialize};
use serde_bytes;
use crate::encode::{to_nson, to_bytes};
use crate::decode::{from_nson, from_bytes};
use crate::msg;
use crate::value::{TimeStamp, Binary};
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct Foo {
a: i32,
b: i64,
c: f64,
d: String,
#[serde(with = "serde_bytes")]
e: Vec<u8>,
t: TimeStamp,
i: MessageId,
j: Binary,
k: NewType,
l: NewType2,
m: NewType3,
n: NewType4,
o: E,
p: Vec<i32>
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct NewType(u64);
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct NewType2(u32, u64);
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct NewType3 { a: i32, b: i64 }
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct NewType4;
#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum E {
M(String),
N(u8),
}
#[test]
fn serialize_and_deserialize() {
let foo = Foo {
a: 1,
b: 2,
c: 3.0,
d: "4".to_string(),
e: vec![1, 2, 3, 4],
t: TimeStamp(123),
i: MessageId::new(),
j : vec![5, 6, 7, 8].into(),
k: NewType(123),
l: NewType2(456, 789),
m: NewType3 { a: 111, b: 222 },
n: NewType4,
o: E::N(123),
p: vec![111, 222]
};
let nson = to_nson(&foo).unwrap();
let foo2: Foo = from_nson(nson).unwrap();
assert_eq!(foo, foo2);
let bytes = to_bytes(&foo).unwrap();
let foo3: Foo = from_bytes(&bytes).unwrap();
assert_eq!(foo, foo3);
}
#[test]
fn binary() {
let byte = vec![1u8, 2, 3, 4];
let msg = msg!{"aa": "bb", "byte": byte.clone()};
let byte2 = msg.get_binary("byte").unwrap();
assert_eq!(byte, byte2.0);
let mut msg2 = msg!{"aa": "bb"};
msg2.insert("byte", byte);
assert_eq!(msg, msg2);
}
}