1 use std::io::Cursor;
2
3 use crate::msgpack::Marker;
4 use crate::msgpack::decode::*;
5
6 #[test]
from_nfix_min()7 fn from_nfix_min() {
8 let buf = [0xe0];
9 let mut cur = Cursor::new(&buf[..]);
10
11 assert_eq!(-32, read_nfix(&mut cur).unwrap());
12 assert_eq!(1, cur.position());
13 }
14
15 #[test]
from_nfix_max()16 fn from_nfix_max() {
17 let buf = [0xff];
18 let mut cur = Cursor::new(&buf[..]);
19
20 assert_eq!(-1, read_nfix(&mut cur).unwrap());
21 assert_eq!(1, cur.position());
22 }
23
24 #[test]
from_nfix_type_mismatch()25 fn from_nfix_type_mismatch() {
26 let buf = &[0xc0];
27 let mut cur = Cursor::new(&buf[..]);
28
29 match read_nfix(&mut cur) {
30 Err(ValueReadError::TypeMismatch(..)) => (),
31 other => panic!("unexpected result: {:?}", other)
32 }
33 assert_eq!(1, cur.position());
34 }
35
36 #[test]
from_i8_min()37 fn from_i8_min() {
38 let buf = [0xd0, 0x80];
39 let mut cur = Cursor::new(&buf[..]);
40
41 assert_eq!(-128, read_i8(&mut cur).unwrap());
42 assert_eq!(2, cur.position());
43 }
44
45 #[test]
from_i8_max()46 fn from_i8_max() {
47 let buf = [0xd0, 0x7f];
48 let mut cur = Cursor::new(&buf[..]);
49
50 assert_eq!(127, read_i8(&mut cur).unwrap());
51 assert_eq!(2, cur.position());
52 }
53
54 #[test]
from_i8_type_mismatch()55 fn from_i8_type_mismatch() {
56 let buf = [0xc0, 0x80];
57 let mut cur = Cursor::new(&buf[..]);
58
59 match read_i8(&mut cur) {
60 Err(ValueReadError::TypeMismatch(Marker::Null)) => (),
61 other => panic!("unexpected result: {:?}", other)
62 }
63 assert_eq!(1, cur.position());
64 }
65
66 #[test]
from_i8_unexpected_eof()67 fn from_i8_unexpected_eof() {
68 let buf = [0xd0];
69 let mut cur = Cursor::new(&buf[..]);
70
71 read_i8(&mut cur).err().unwrap();
72 assert_eq!(1, cur.position());
73 }
74
75 #[test]
from_i16_min()76 fn from_i16_min() {
77 let buf = [0xd1, 0x80, 0x00];
78 let mut cur = Cursor::new(&buf[..]);
79
80 assert_eq!(-32768, read_i16(&mut cur).unwrap());
81 assert_eq!(3, cur.position());
82 }
83
84 #[test]
from_i16_max()85 fn from_i16_max() {
86 let buf = [0xd1, 0x7f, 0xff];
87 let mut cur = Cursor::new(&buf[..]);
88
89 assert_eq!(32767, read_i16(&mut cur).unwrap());
90 assert_eq!(3, cur.position());
91 }
92
93 #[test]
from_i16_type_mismatch()94 fn from_i16_type_mismatch() {
95 let buf = [0xc0, 0x80, 0x00];
96 let mut cur = Cursor::new(&buf[..]);
97
98 match read_i16(&mut cur) {
99 Err(ValueReadError::TypeMismatch(Marker::Null)) => (),
100 other => panic!("unexpected result: {:?}", other)
101 }
102 assert_eq!(1, cur.position());
103 }
104
105 #[test]
from_i16_unexpected_eof()106 fn from_i16_unexpected_eof() {
107 let buf = [0xd1, 0x7f];
108 let mut cur = Cursor::new(&buf[..]);
109
110 read_i16(&mut cur).err().unwrap();
111 assert!(cur.position() >= 1);
112 }
113
114 #[test]
from_i32_min()115 fn from_i32_min() {
116 let buf = [0xd2, 0x80, 0x00, 0x00, 0x00];
117 let mut cur = Cursor::new(&buf[..]);
118
119 assert_eq!(-2147483648, read_i32(&mut cur).unwrap());
120 assert_eq!(5, cur.position());
121 }
122
123 #[test]
from_i32_max()124 fn from_i32_max() {
125 let buf = &[0xd2, 0x7f, 0xff, 0xff, 0xff];
126 let mut cur = Cursor::new(&buf[..]);
127
128 assert_eq!(2147483647, read_i32(&mut cur).unwrap());
129 assert_eq!(5, cur.position());
130 }
131
132 #[test]
from_i32_type_mismatch()133 fn from_i32_type_mismatch() {
134 let buf = &[0xc0, 0x80, 0x00, 0x00, 0x00];
135 let mut cur = Cursor::new(&buf[..]);
136
137 match read_i32(&mut cur) {
138 Err(ValueReadError::TypeMismatch(Marker::Null)) => (),
139 other => panic!("unexpected result: {:?}", other)
140 }
141 assert_eq!(1, cur.position());
142 }
143
144 #[test]
from_i32_unexpected_eof()145 fn from_i32_unexpected_eof() {
146 let buf = &[0xd2, 0x7f, 0xff, 0xff];
147 let mut cur = Cursor::new(&buf[..]);
148
149 read_i32(&mut cur).err().unwrap();
150 assert!(cur.position() >= 1);
151 }
152
153 #[test]
from_i64_min()154 fn from_i64_min() {
155 let buf = [0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
156 let mut cur = Cursor::new(&buf[..]);
157
158 assert_eq!(-9223372036854775808, read_i64(&mut cur).unwrap());
159 assert_eq!(9, cur.position());
160 }
161
162 #[test]
from_i64_max()163 fn from_i64_max() {
164 let buf = [0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
165 let mut cur = Cursor::new(&buf[..]);
166
167 assert_eq!(9223372036854775807, read_i64(&mut cur).unwrap());
168 assert_eq!(9, cur.position());
169 }
170
171 #[test]
from_i64_type_mismatch()172 fn from_i64_type_mismatch() {
173 let buf = [0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
174 let mut cur = Cursor::new(&buf[..]);
175
176 match read_i64(&mut cur) {
177 Err(ValueReadError::TypeMismatch(Marker::Null)) => (),
178 other => panic!("unexpected result: {:?}", other)
179 }
180 assert_eq!(1, cur.position());
181 }
182
183 #[test]
from_i64_unexpected_eof()184 fn from_i64_unexpected_eof() {
185 let buf = [0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
186 let mut cur = Cursor::new(&buf[..]);
187
188 read_i64(&mut cur).err().unwrap();
189 assert!(cur.position() >= 1);
190 }
191
192 #[test]
from_nfix_min_read_int()193 fn from_nfix_min_read_int() {
194 let buf: &[u8] = &[0xe0];
195 let mut cur = Cursor::new(buf);
196
197 assert_eq!(-32, read_int(&mut cur).unwrap());
198 assert_eq!(1, cur.position());
199 }
200
201 #[test]
from_nfix_max_read_int()202 fn from_nfix_max_read_int() {
203 let buf: &[u8] = &[0xff];
204 let mut cur = Cursor::new(buf);
205
206 assert_eq!(-1, read_int(&mut cur).unwrap());
207 assert_eq!(1, cur.position());
208 }
209
210 #[test]
from_i8_min_read_int()211 fn from_i8_min_read_int() {
212 let buf: &[u8] = &[0xd0, 0x80];
213 let mut cur = Cursor::new(buf);
214
215 assert_eq!(-128, read_int(&mut cur).unwrap());
216 assert_eq!(2, cur.position());
217 }
218
219 #[test]
from_i8_max_read_int()220 fn from_i8_max_read_int() {
221 let buf: &[u8] = &[0xd0, 0x7f];
222 let mut cur = Cursor::new(buf);
223
224 assert_eq!(127, read_int(&mut cur).unwrap());
225 assert_eq!(2, cur.position());
226 }
227
228 #[test]
from_i16_min_read_int()229 fn from_i16_min_read_int() {
230 let buf: &[u8] = &[0xd1, 0x80, 0x00];
231 let mut cur = Cursor::new(buf);
232
233 assert_eq!(-32768, read_int(&mut cur).unwrap());
234 assert_eq!(3, cur.position());
235 }
236
237 #[test]
from_i16_max_read_int()238 fn from_i16_max_read_int() {
239 let buf: &[u8] = &[0xd1, 0x7f, 0xff];
240 let mut cur = Cursor::new(buf);
241
242 assert_eq!(32767, read_int(&mut cur).unwrap());
243 assert_eq!(3, cur.position());
244 }
245
246 #[test]
from_i32_min_read_int()247 fn from_i32_min_read_int() {
248 let buf: &[u8] = &[0xd2, 0x80, 0x00, 0x00, 0x00];
249 let mut cur = Cursor::new(buf);
250
251 assert_eq!(-2147483648, read_int(&mut cur).unwrap());
252 assert_eq!(5, cur.position());
253 }
254
255 #[test]
from_i32_max_read_int()256 fn from_i32_max_read_int() {
257 let buf: &[u8] = &[0xd2, 0x7f, 0xff, 0xff, 0xff];
258 let mut cur = Cursor::new(buf);
259
260 assert_eq!(2147483647, read_int(&mut cur).unwrap());
261 assert_eq!(5, cur.position());
262 }
263
264 #[test]
from_i64_min_read_int()265 fn from_i64_min_read_int() {
266 let buf: &[u8] = &[0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
267 let mut cur = Cursor::new(buf);
268
269 assert_eq!(-9223372036854775808i64, read_int(&mut cur).unwrap());
270 assert_eq!(9, cur.position());
271 }
272
273 #[test]
from_i64_max_read_int()274 fn from_i64_max_read_int() {
275 let buf: &[u8] = &[0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
276 let mut cur = Cursor::new(buf);
277
278 assert_eq!(9223372036854775807i64, read_int(&mut cur).unwrap());
279 assert_eq!(9, cur.position());
280 }
281