1 use std::io::Cursor;
2
3 use crate::msgpack::Marker;
4 use crate::msgpack::decode::*;
5
6 #[test]
from_positive_fixnum()7 fn from_positive_fixnum() {
8 let buf = [0x00, 0x7f, 0x20];
9 let mut cur = Cursor::new(&buf[..]);
10
11 assert_eq!(0u8, read_pfix(&mut cur).unwrap());
12 assert_eq!(1, cur.position());
13
14 assert_eq!(127u8, read_pfix(&mut cur).unwrap());
15 assert_eq!(2, cur.position());
16
17 assert_eq!(32u8, read_pfix(&mut cur).unwrap());
18 assert_eq!(3, cur.position());
19 }
20
21 #[test]
from_u8_min()22 fn from_u8_min() {
23 let buf = [0xcc, 0x00];
24 let mut cur = Cursor::new(&buf[..]);
25
26 assert_eq!(0, read_u8(&mut cur).unwrap());
27 assert_eq!(2, cur.position());
28 }
29
30 #[test]
from_u8_max()31 fn from_u8_max() {
32 let buf = [0xcc, 0xff];
33 let mut cur = Cursor::new(&buf[..]);
34
35 assert_eq!(255, read_u8(&mut cur).unwrap());
36 assert_eq!(2, cur.position());
37 }
38
39 #[test]
from_u8_type_mismatch()40 fn from_u8_type_mismatch() {
41 let buf = [0xc0, 0x80];
42 let mut cur = Cursor::new(&buf[..]);
43
44 match read_u8(&mut cur) {
45 Err(ValueReadError::TypeMismatch(Marker::Null)) => (),
46 other => panic!("unexpected result: {:?}", other)
47 }
48 assert_eq!(1, cur.position());
49 }
50
51 #[test]
from_u8_unexpected_eof()52 fn from_u8_unexpected_eof() {
53 let buf = [0xcc];
54 let mut cur = Cursor::new(&buf[..]);
55
56 read_u8(&mut cur).err().unwrap();
57 assert_eq!(1, cur.position());
58 }
59
60 #[test]
from_u16_min()61 fn from_u16_min() {
62 let buf = [0xcd, 0x00, 0x00];
63 let mut cur = Cursor::new(&buf[..]);
64
65 assert_eq!(0, read_u16(&mut cur).unwrap());
66 assert_eq!(3, cur.position());
67 }
68
69 #[test]
from_u32_max()70 fn from_u32_max() {
71 let buf = [0xce, 0xff, 0xff, 0xff, 0xff];
72 let mut cur = Cursor::new(&buf[..]);
73
74 assert_eq!(4294967295, read_u32(&mut cur).unwrap());
75 assert_eq!(5, cur.position());
76 }
77
78 #[test]
from_unsigned_fixnum_read_int()79 fn from_unsigned_fixnum_read_int() {
80 let buf = [0x00, 0x7f, 0x20];
81 let mut cur = Cursor::new(&buf[..]);
82
83 assert_eq!(0u64, read_int(&mut cur).unwrap());
84 assert_eq!(1, cur.position());
85
86 assert_eq!(127u64, read_int(&mut cur).unwrap());
87 assert_eq!(2, cur.position());
88
89 assert_eq!(32u64, read_int(&mut cur).unwrap());
90 assert_eq!(3, cur.position());
91 }
92
93 #[test]
from_unsigned_u8_read_int()94 fn from_unsigned_u8_read_int() {
95 let buf = [0xcc, 0x80, 0xcc, 0xff];
96 let mut cur = Cursor::new(&buf[..]);
97
98 assert_eq!(128u64, read_int(&mut cur).unwrap());
99 assert_eq!(2, cur.position());
100
101 assert_eq!(255u64, read_int(&mut cur).unwrap());
102 assert_eq!(4, cur.position());
103 }
104
105 #[test]
from_unsigned_u8_incomplete_read_int()106 fn from_unsigned_u8_incomplete_read_int() {
107 let buf = [0xcc];
108 let mut cur = Cursor::new(&buf[..]);
109
110 read_int::<u64, _>(&mut cur).err().unwrap();
111 assert_eq!(1, cur.position());
112 }
113
114 #[test]
from_unsigned_u16_read_int()115 fn from_unsigned_u16_read_int() {
116 let buf = [0xcd, 0x01, 0x00, 0xcd, 0xff, 0xff];
117 let mut cur = Cursor::new(&buf[..]);
118
119 assert_eq!(256u64, read_int(&mut cur).unwrap());
120 assert_eq!(3, cur.position());
121
122 assert_eq!(65535u64, read_int(&mut cur).unwrap());
123 assert_eq!(6, cur.position());
124 }
125
126 #[test]
from_unsigned_u16_incomplete_read_int()127 fn from_unsigned_u16_incomplete_read_int() {
128 let buf = [0xcd];
129 let mut cur = Cursor::new(&buf[..]);
130
131 read_int::<u64, _>(&mut cur).err().unwrap();
132 assert_eq!(1, cur.position());
133 }
134
135 #[test]
from_unsigned_u32_read_int()136 fn from_unsigned_u32_read_int() {
137 let buf = [0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xff];
138 let mut cur = Cursor::new(&buf[..]);
139
140 assert_eq!(65536u64, read_int(&mut cur).unwrap());
141 assert_eq!(5, cur.position());
142
143 assert_eq!(4294967295u64, read_int(&mut cur).unwrap());
144 assert_eq!(10, cur.position());
145 }
146
147 #[test]
from_unsigned_u32_incomplete_read_int()148 fn from_unsigned_u32_incomplete_read_int() {
149 let buf = [0xce];
150 let mut cur = Cursor::new(&buf[..]);
151
152 read_int::<u64, _>(&mut cur).err().unwrap();
153 assert_eq!(1, cur.position());
154 }
155
156 #[test]
from_unsigned_u64_read_int()157 fn from_unsigned_u64_read_int() {
158 let buf = [
159 0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
160 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
161 ];
162 let mut cur = Cursor::new(&buf[..]);
163
164 assert_eq!(4294967296u64, read_int(&mut cur).unwrap());
165 assert_eq!(9, cur.position());
166
167 assert_eq!(18446744073709551615u64, read_int(&mut cur).unwrap());
168 assert_eq!(18, cur.position());
169 }
170
171 #[test]
from_unsigned_u64_incomplete_read_int()172 fn from_unsigned_u64_incomplete_read_int() {
173 let buf = [0xcf];
174 let mut cur = Cursor::new(&buf[..]);
175
176 read_int::<u64, _>(&mut cur).err().unwrap();
177 assert_eq!(1, cur.position());
178 }
179
180 #[test]
from_unsigned_invalid_marker_read_int()181 fn from_unsigned_invalid_marker_read_int() {
182 let buf = [0xc0];
183 let mut cur = Cursor::new(&buf[..]);
184
185 match read_int::<u64, _>(&mut cur) {
186 Err(NumValueReadError::TypeMismatch(Marker::Null)) => (),
187 other => panic!("unexpected result: {:?}", other)
188 }
189 assert_eq!(1, cur.position());
190 }
191
192 #[test]
from_unsigned_invalid_unknown_marker_read_int()193 fn from_unsigned_invalid_unknown_marker_read_int() {
194 let buf = [0xc1];
195 let mut cur = Cursor::new(&buf[..]);
196
197 match read_int::<u64, _>(&mut cur) {
198 Err(NumValueReadError::TypeMismatch(Marker::Reserved)) => (),
199 other => panic!("unexpected result: {:?}", other)
200 }
201 assert_eq!(1, cur.position());
202 }
203