1 extern crate rmp_serde as rmps;
2
3 use std::io::Cursor;
4 use std::fmt::{self, Formatter};
5
6 use serde::de;
7 use serde::Deserialize;
8
9 use rmp::Marker;
10 use crate::rmps::{Deserializer, Raw, RawRef};
11 use crate::rmps::decode::{self, Error};
12
13 #[test]
pass_nil()14 fn pass_nil() {
15 let buf = [0xc0];
16 let mut de = Deserializer::new(&buf[..]);
17 assert_eq!((), Deserialize::deserialize(&mut de).unwrap());
18 }
19
20 #[test]
fail_nil_from_reserved()21 fn fail_nil_from_reserved() {
22 let buf = [0xc1];
23 let mut de = Deserializer::new(&buf[..]);
24
25 let res: Result<(), Error> = Deserialize::deserialize(&mut de);
26 match res.err() {
27 Some(Error::TypeMismatch(Marker::Reserved)) => (),
28 other => panic!("unexpected result: {:?}", other)
29 }
30 }
31
32 #[test]
pass_bool()33 fn pass_bool() {
34 let buf = [0xc3, 0xc2];
35 let mut de = Deserializer::new(&buf[..]);
36
37 assert_eq!(true, Deserialize::deserialize(&mut de).unwrap());
38 assert_eq!(false, Deserialize::deserialize(&mut de).unwrap());
39 }
40
41 #[test]
fail_bool_from_fixint()42 fn fail_bool_from_fixint() {
43 let buf = [0x00];
44 let cur = Cursor::new(&buf[..]);
45
46 let mut deserializer = Deserializer::new(cur);
47
48 let res: Result<bool, Error> = Deserialize::deserialize(&mut deserializer);
49 match res.err().unwrap() {
50 Error::Syntax(..) => (),
51 other => panic!("unexpected result: {:?}", other)
52 }
53 }
54
55 #[test]
pass_u64()56 fn pass_u64() {
57 let buf = [0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
58 let cur = Cursor::new(&buf[..]);
59
60 let mut de = Deserializer::new(cur);
61
62 assert_eq!(18446744073709551615u64, Deserialize::deserialize(&mut de).unwrap());
63 }
64
65 #[test]
pass_u32()66 fn pass_u32() {
67 let buf = [0xce, 0xff, 0xff, 0xff, 0xff];
68 let cur = Cursor::new(&buf[..]);
69
70 let mut de = Deserializer::new(cur);
71
72 assert_eq!(4294967295u32, Deserialize::deserialize(&mut de).unwrap());
73 }
74
75 #[test]
fail_u32_from_u64()76 fn fail_u32_from_u64() {
77 let buf = [0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
78 let cur = Cursor::new(&buf[..]);
79
80 let mut de = Deserializer::new(cur);
81
82 let res: Result<u32, Error> = Deserialize::deserialize(&mut de);
83 match res.err().unwrap() {
84 Error::Syntax(..) => (),
85 other => panic!("unexpected result: {:?}", other)
86 }
87 }
88
89 #[test]
pass_u16()90 fn pass_u16() {
91 let buf = [0xcd, 0xff, 0xff];
92 let cur = Cursor::new(&buf[..]);
93
94 let mut de = Deserializer::new(cur);
95
96 assert_eq!(65535u16, Deserialize::deserialize(&mut de).unwrap());
97 }
98
99 #[test]
pass_u8()100 fn pass_u8() {
101 let buf = [0xcc, 0xff];
102 let cur = Cursor::new(&buf[..]);
103
104 let mut de = Deserializer::new(cur);
105
106 assert_eq!(255u8, Deserialize::deserialize(&mut de).unwrap());
107 }
108
109 #[test]
pass_u8_from_64()110 fn pass_u8_from_64() {
111 let buf = [0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a];
112 let cur = Cursor::new(&buf[..]);
113
114 let mut de = Deserializer::new(cur);
115
116 assert_eq!(42u8, Deserialize::deserialize(&mut de).unwrap());
117 }
118
119 #[test]
pass_usize()120 fn pass_usize() {
121 let buf = [0xcc, 0xff];
122 let cur = Cursor::new(&buf[..]);
123
124 let mut de = Deserializer::new(cur);
125
126 assert_eq!(255usize, Deserialize::deserialize(&mut de).unwrap());
127 }
128
129 #[test]
pass_i64()130 fn pass_i64() {
131 let buf = [0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
132 let cur = Cursor::new(&buf[..]);
133
134 let mut de = Deserializer::new(cur);
135
136 assert_eq!(9223372036854775807i64, Deserialize::deserialize(&mut de).unwrap());
137 }
138
139 #[test]
pass_i32()140 fn pass_i32() {
141 let buf = [0xd2, 0x7f, 0xff, 0xff, 0xff];
142 let cur = Cursor::new(&buf[..]);
143
144 let mut de = Deserializer::new(cur);
145
146 assert_eq!(2147483647i32, Deserialize::deserialize(&mut de).unwrap());
147 }
148
149 #[test]
pass_i16()150 fn pass_i16() {
151 let buf = [0xd1, 0x7f, 0xff];
152 let cur = Cursor::new(&buf[..]);
153
154 let mut de = Deserializer::new(cur);
155
156 assert_eq!(32767i16, Deserialize::deserialize(&mut de).unwrap());
157 }
158
159 #[test]
pass_i8()160 fn pass_i8() {
161 let buf = [0xd0, 0x7f];
162 let cur = Cursor::new(&buf[..]);
163
164 let mut de = Deserializer::new(cur);
165
166 assert_eq!(127i8, Deserialize::deserialize(&mut de).unwrap());
167 }
168
169 #[test]
pass_isize()170 fn pass_isize() {
171 let buf = [0xd0, 0x7f];
172 let cur = Cursor::new(&buf[..]);
173
174 let mut de = Deserializer::new(cur);
175
176 assert_eq!(127isize, Deserialize::deserialize(&mut de).unwrap());
177 }
178
179 #[test]
pass_f32()180 fn pass_f32() {
181 let buf = [0xca, 0x7f, 0x7f, 0xff, 0xff];
182 let cur = Cursor::new(&buf[..]);
183
184 let mut de = Deserializer::new(cur);
185
186 assert_eq!(3.4028234e38_f32, Deserialize::deserialize(&mut de).unwrap());
187 }
188
189 #[test]
pass_f64()190 fn pass_f64() {
191 let buf = [0xcb, 0x40, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
192 let cur = Cursor::new(&buf[..]);
193
194 let mut de = Deserializer::new(cur);
195
196 assert_eq!(42f64, Deserialize::deserialize(&mut de).unwrap());
197 }
198
199 // spot check tests for general integers -> float conversions
200
201 #[test]
pass_i8_as_f32()202 fn pass_i8_as_f32() {
203 let buf = [0xd0, 0x7f];
204 let cur = Cursor::new(&buf[..]);
205
206 let mut de = Deserializer::new(cur);
207
208 assert_eq!(127f32, Deserialize::deserialize(&mut de).unwrap());
209 }
210
211 #[test]
pass_u32_as_f64()212 fn pass_u32_as_f64() {
213 let buf = [0xce, 0xff, 0xff, 0xff, 0xff];
214 let cur = Cursor::new(&buf[..]);
215
216 let mut de = Deserializer::new(cur);
217
218 assert_eq!(4294967295f64, Deserialize::deserialize(&mut de).unwrap());
219 }
220
221 #[test]
pass_string()222 fn pass_string() {
223 let buf = [0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
224 let cur = Cursor::new(&buf[..]);
225
226 let mut de = Deserializer::new(cur);
227 let actual: String = Deserialize::deserialize(&mut de).unwrap();
228
229 assert_eq!("le message".to_string(), actual);
230 }
231
232 #[test]
pass_tuple()233 fn pass_tuple() {
234 let buf = [0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94];
235 let cur = Cursor::new(&buf[..]);
236
237 let mut de = Deserializer::new(cur);
238 let actual: (u32, u32) = Deserialize::deserialize(&mut de).unwrap();
239
240 assert_eq!((42, 100500), actual);
241 }
242
243 #[ignore]
244 #[test]
fail_tuple_len_mismatch()245 fn fail_tuple_len_mismatch() {
246 let buf = [0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94];
247 let cur = Cursor::new(&buf[..]);
248
249 let mut de = Deserializer::new(cur);
250 let actual: Result<(u32,), Error> = Deserialize::deserialize(&mut de);
251
252 match actual.err().unwrap() {
253 Error::LengthMismatch(1) => (),
254 other => panic!("unexpected result: {:?}", other)
255 }
256 }
257
258 #[test]
pass_option_some()259 fn pass_option_some() {
260 let buf = [0x1f];
261
262 let mut de = Deserializer::new(&buf[..]);
263 let actual: Option<u8> = Deserialize::deserialize(&mut de).unwrap();
264 assert_eq!(Some(31), actual);
265 }
266
267 #[test]
pass_option_none()268 fn pass_option_none() {
269 let buf = [0xc0];
270
271 let mut de = Deserializer::new(&buf[..]);
272 let actual: Option<u8> = Deserialize::deserialize(&mut de).unwrap();
273 assert_eq!(None, actual);
274 }
275
276 #[test]
fail_option_u8_from_reserved()277 fn fail_option_u8_from_reserved() {
278 let buf = [0xc1];
279 let cur = Cursor::new(&buf[..]);
280
281 let mut de = Deserializer::new(cur);
282 let actual: Result<Option<u8>, Error> = Deserialize::deserialize(&mut de);
283 match actual.err() {
284 Some(Error::TypeMismatch(Marker::Reserved)) => (),
285 other => panic!("unexpected result: {:?}", other)
286 }
287 }
288
289 #[test]
pass_vector()290 fn pass_vector() {
291 let buf = [0x92, 0x00, 0xcc, 0x80];
292 let cur = Cursor::new(&buf[..]);
293
294 let mut de = Deserializer::new(cur);
295 let actual: Vec<u8> = Deserialize::deserialize(&mut de).unwrap();
296 assert_eq!(vec![0, 128], actual);
297 }
298
299 #[test]
pass_map()300 fn pass_map() {
301 use std::collections::HashMap;
302
303 let buf = [
304 0x82, // 2 (size)
305 0xa3, 0x69, 0x6e, 0x74, // 'int'
306 0xcc, 0x80, // 128
307 0xa3, 0x6b, 0x65, 0x79, // 'key'
308 0x2a // 42
309 ];
310 let cur = Cursor::new(&buf[..]);
311
312 let mut de = Deserializer::new(cur);
313 let actual = Deserialize::deserialize(&mut de).unwrap();
314 let mut expected = HashMap::new();
315 expected.insert("int".to_string(), 128);
316 expected.insert("key".to_string(), 42);
317
318 assert_eq!(expected, actual);
319 }
320
321 // TODO: Merge three of them.
322 #[test]
pass_bin8_into_bytebuf()323 fn pass_bin8_into_bytebuf() {
324 use serde_bytes::ByteBuf;
325
326 let buf = [0xc4, 0x02, 0xcc, 0x80];
327 let cur = Cursor::new(&buf[..]);
328
329 let mut de = Deserializer::new(cur);
330 let actual: ByteBuf = Deserialize::deserialize(&mut de).unwrap();
331
332 assert_eq!([0xcc, 0x80], actual[..]);
333 }
334
335 #[test]
pass_bin16_into_bytebuf()336 fn pass_bin16_into_bytebuf() {
337 use serde_bytes::ByteBuf;
338
339 let buf = [0xc5, 0x00, 0x02, 0xcc, 0x80];
340 let cur = Cursor::new(&buf[..]);
341
342 let mut de = Deserializer::new(cur);
343 let actual: ByteBuf = Deserialize::deserialize(&mut de).unwrap();
344
345 assert_eq!([0xcc, 0x80], actual[..]);
346 }
347
348 #[test]
pass_bin32_into_bytebuf()349 fn pass_bin32_into_bytebuf() {
350 use serde_bytes::ByteBuf;
351
352 let buf = [0xc6, 0x00, 0x00, 0x00, 0x02, 0xcc, 0x80];
353 let cur = Cursor::new(&buf[..]);
354
355 let mut de = Deserializer::new(cur);
356 let actual: ByteBuf = Deserialize::deserialize(&mut de).unwrap();
357
358 assert_eq!([0xcc, 0x80], actual[..]);
359 }
360
361 #[test]
pass_bin8_into_bytebuf_regression_growing_buffer()362 fn pass_bin8_into_bytebuf_regression_growing_buffer() {
363 use serde_bytes::ByteBuf;
364
365 // Try to deserialize large buf and a small buf
366 let buf = [0x92, 0xc4, 0x04, 0x71, 0x75, 0x75, 0x78, 0xc4, 0x03, 0x62, 0x61, 0x72];
367 let cur = Cursor::new(&buf[..]);
368
369 let mut de = Deserializer::new(cur);
370 let (large, small): (ByteBuf, ByteBuf) = Deserialize::deserialize(&mut de).unwrap();
371 let (large, small): (Vec<u8>, Vec<u8>) = (large.into_vec(), small.into_vec());
372
373 assert_eq!((b"quux".to_vec(), b"bar".to_vec()), (large, small));
374 }
375
376 #[test]
test_deserialize_numeric()377 fn test_deserialize_numeric() {
378 #[derive(Debug, PartialEq)]
379 enum FloatOrInteger {
380 Float(f64),
381 Integer(u64),
382 }
383
384 impl<'de> de::Deserialize<'de> for FloatOrInteger {
385 fn deserialize<D>(de: D) -> Result<FloatOrInteger, D::Error>
386 where D: de::Deserializer<'de>
387 {
388 struct FloatOrIntegerVisitor;
389
390 impl<'de> de::Visitor<'de> for FloatOrIntegerVisitor {
391 type Value = FloatOrInteger;
392
393 fn expecting(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
394 write!(fmt, "either a float or an integer")
395 }
396
397 fn visit_u64<E>(self, value: u64) -> Result<FloatOrInteger, E> {
398 Ok(FloatOrInteger::Integer(value))
399 }
400
401 fn visit_f64<E>(self, value: f64) -> Result<FloatOrInteger, E> {
402 Ok(FloatOrInteger::Float(value))
403 }
404 }
405 de.deserialize_any(FloatOrIntegerVisitor)
406 }
407 }
408
409 let buf = [203, 64, 36, 102, 102, 102, 102, 102, 102]; // 10.2
410 let mut de = Deserializer::new(&buf[..]);
411 let x: FloatOrInteger = Deserialize::deserialize(&mut de).unwrap();
412 assert_eq!(x, FloatOrInteger::Float(10.2));
413
414 let buf = [36]; // 36
415 let mut de = Deserializer::new(&buf[..]);
416 let x: FloatOrInteger = Deserialize::deserialize(&mut de).unwrap();
417 assert_eq!(x, FloatOrInteger::Integer(36));
418 }
419
420 #[test]
pass_deserializer_get_ref()421 fn pass_deserializer_get_ref() {
422 let buf = [0xc0];
423 let cur = Cursor::new(&buf[..]);
424
425 let mut de = Deserializer::new(cur);
426
427 assert_eq!((), Deserialize::deserialize(&mut de).unwrap());
428 assert_eq!(1, de.get_ref().position());
429 }
430
431 #[test]
pass_deserializer_get_mut()432 fn pass_deserializer_get_mut() {
433 let buf = [0xc0];
434 let cur = Cursor::new(&buf[..]);
435
436 let mut de = Deserializer::new(cur);
437
438 assert_eq!((), Deserialize::deserialize(&mut de).unwrap());
439 de.get_mut().set_position(0);
440
441 assert_eq!((), Deserialize::deserialize(&mut de).unwrap());
442 }
443
444 #[test]
pass_deserializer_into_inner()445 fn pass_deserializer_into_inner() {
446 let buf = [0xc0];
447 let cur = Cursor::new(&buf[..]);
448
449 let mut de = Deserializer::new(cur);
450
451 assert_eq!((), Deserialize::deserialize(&mut de).unwrap());
452 let cur = de.into_inner();
453
454 assert_eq!(1, cur.position());
455 }
456
457 #[test]
pass_deserializer_cursor_position()458 fn pass_deserializer_cursor_position() {
459 let mut de = Deserializer::new(Cursor::new(vec![0xce, 0xff, 0xff, 0xff, 0xff]));
460
461 assert_eq!(4294967295u32, Deserialize::deserialize(&mut de).unwrap());
462 assert_eq!(5, de.position());
463 }
464
465 #[test]
pass_from()466 fn pass_from() {
467 assert_eq!(2147483647, decode::from_read(&[0xd2, 0x7f, 0xff, 0xff, 0xff][..]).unwrap());
468 }
469
470 #[test]
pass_raw_valid_utf8()471 fn pass_raw_valid_utf8() {
472 let buf = vec![0xa3, 0x6b, 0x65, 0x79];
473 let raw: Raw = rmps::from_slice(&buf[..]).unwrap();
474
475 assert!(raw.is_str());
476 assert_eq!("key", raw.as_str().unwrap());
477 assert_eq!([0x6b, 0x65, 0x79], raw.as_bytes());
478 }
479
480 #[test]
pass_raw_invalid_utf8()481 fn pass_raw_invalid_utf8() {
482 // >>> msgpack.dumps(msgpack.dumps([200, []]))
483 // '\xa4\x92\xcc\xc8\x90'
484 let buf = vec![0xa4, 0x92, 0xcc, 0xc8, 0x90];
485 let raw: Raw = rmps::from_slice(&buf[..]).unwrap();
486
487 assert!(raw.is_err());
488 assert_eq!(0, raw.as_err().unwrap().valid_up_to());
489 assert_eq!([0x92, 0xcc, 0xc8, 0x90], raw.as_bytes());
490 }
491
492 #[test]
pass_raw_ref_valid_utf8()493 fn pass_raw_ref_valid_utf8() {
494 let buf = vec![0xa3, 0x6b, 0x65, 0x79];
495 let raw: RawRef<'_> = rmps::from_slice(&buf[..]).unwrap();
496
497 assert!(raw.is_str());
498 assert_eq!("key", raw.as_str().unwrap());
499 assert_eq!([0x6b, 0x65, 0x79], raw.as_bytes());
500 }
501
502 #[test]
pass_raw_ref_invalid_utf8()503 fn pass_raw_ref_invalid_utf8() {
504 // >>> msgpack.dumps(msgpack.dumps([200, []]))
505 // '\xa4\x92\xcc\xc8\x90'
506 let buf = vec![0xa4, 0x92, 0xcc, 0xc8, 0x90];
507 let raw: RawRef<'_> = rmps::from_slice(&buf[..]).unwrap();
508
509 assert!(raw.is_err());
510 assert_eq!(0, raw.as_err().unwrap().valid_up_to());
511 assert_eq!([0x92, 0xcc, 0xc8, 0x90], raw.as_bytes());
512 }
513
514 #[test]
fail_str_invalid_utf8()515 fn fail_str_invalid_utf8() {
516 let buf = vec![0xa4, 0x92, 0xcc, 0xc8, 0x90];
517 let err: Result<String, decode::Error> = rmps::from_slice(&buf[..]);
518
519 assert!(err.is_err());
520 match err.err().unwrap() {
521 decode::Error::Utf8Error(err) => assert_eq!(0, err.valid_up_to()),
522 // decode::Error::Syntax(err) => {}
523 err => panic!("unexpected error: {:?}", err),
524 }
525 }
526