1use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
2use std::{convert::TryInto, fmt::{self, Display, Formatter}};
3use std::io::{self, Cursor, Read, Write};
4
5pub trait Packable {
6 type Error;
7
8 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error>;
9 fn pack(&self) -> Result<Vec<u8>, Self::Error> {
10 let mut wtr = Vec::new();
11 self.pack_into(&mut wtr)?;
12 Ok(wtr)
13 }
14}
15pub trait Unpackable where Self: Sized {
16 type Error;
17
18 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error>;
19 fn unpack<'a>(buf: &'a [u8]) -> Result<(Self, &'a [u8]), Self::Error> {
20 let mut rdr = Cursor::new(buf);
21 let val = Self::unpack_from(&mut rdr)?;
22 Ok((val, &buf[rdr.position() as usize..]))
23 }
24}
25
26#[derive(Debug, PartialEq)]
27pub enum PackError {
28 SizeError,
29}
30impl Display for PackError {
31 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
32 match self {
33 Self::SizeError => write!(f, "buffer is too small"),
34 }
35 }
36}
37impl std::error::Error for PackError {}
38impl From<io::Error> for PackError {
39 fn from(e: io::Error) -> Self {
40 match e.kind() {
41 io::ErrorKind::UnexpectedEof => Self::SizeError,
42 _ => unreachable!(),
43 }
44 }
45}
46
47impl Packable for bool {
48 type Error = io::Error;
49
50 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
51 stream.write_u8(if *self {1} else {0})?;
52 Ok(())
53 }
54}
55impl Unpackable for bool {
56 type Error = PackError;
57
58 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
59 Ok(rdr.read_u8()? != 0)
60 }
61}
62
63impl Packable for u8 {
64 type Error = io::Error;
65
66 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
67 stream.write_u8(*self)?;
68 Ok(())
69 }
70}
71impl Unpackable for u8 {
72 type Error = PackError;
73
74 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
75 Ok(rdr.read_u8()?)
76 }
77}
78
79impl Packable for i8 {
80 type Error = io::Error;
81
82 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
83 stream.write_i8(*self)?;
84 Ok(())
85 }
86}
87impl Unpackable for i8 {
88 type Error = PackError;
89
90 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
91 Ok(rdr.read_i8()?)
92 }
93}
94
95impl Packable for u16 {
96 type Error = io::Error;
97
98 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
99 stream.write_u16::<BigEndian>(*self)?;
100 Ok(())
101 }
102}
103impl Unpackable for u16 {
104 type Error = PackError;
105
106 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
107 Ok(rdr.read_u16::<BigEndian>()?)
108 }
109}
110
111impl Packable for i16 {
112 type Error = io::Error;
113
114 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
115 stream.write_i16::<BigEndian>(*self)?;
116 Ok(())
117 }
118}
119impl Unpackable for i16 {
120 type Error = PackError;
121
122 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
123 Ok(rdr.read_i16::<BigEndian>()?)
124 }
125}
126
127impl Packable for u32 {
128 type Error = io::Error;
129
130 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
131 stream.write_u32::<BigEndian>(*self)?;
132 Ok(())
133 }
134}
135impl Unpackable for u32 {
136 type Error = PackError;
137
138 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
139 Ok(rdr.read_u32::<BigEndian>()?)
140 }
141}
142
143impl Packable for i32 {
144 type Error = io::Error;
145
146 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
147 stream.write_i32::<BigEndian>(*self)?;
148 Ok(())
149 }
150}
151impl Unpackable for i32 {
152 type Error = PackError;
153
154 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
155 Ok(rdr.read_i32::<BigEndian>()?)
156 }
157}
158
159impl Packable for u64 {
160 type Error = io::Error;
161
162 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
163 stream.write_u64::<BigEndian>(*self)?;
164 Ok(())
165 }
166}
167impl Unpackable for u64 {
168 type Error = PackError;
169
170 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
171 Ok(rdr.read_u64::<BigEndian>()?)
172 }
173}
174
175impl Packable for i64 {
176 type Error = io::Error;
177
178 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
179 stream.write_i64::<BigEndian>(*self)?;
180 Ok(())
181 }
182}
183impl Unpackable for i64 {
184 type Error = PackError;
185
186 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
187 Ok(rdr.read_i64::<BigEndian>()?)
188 }
189}
190
191impl Packable for u128 {
192 type Error = io::Error;
193
194 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
195 stream.write_u128::<BigEndian>(*self)?;
196 Ok(())
197 }
198}
199impl Unpackable for u128 {
200 type Error = PackError;
201
202 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
203 Ok(rdr.read_u128::<BigEndian>()?)
204 }
205}
206
207impl Packable for i128 {
208 type Error = io::Error;
209
210 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
211 stream.write_i128::<BigEndian>(*self)?;
212 Ok(())
213 }
214}
215impl Unpackable for i128 {
216 type Error = PackError;
217
218 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
219 Ok(rdr.read_i128::<BigEndian>()?)
220 }
221}
222
223impl Packable for f32 {
224 type Error = io::Error;
225
226 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
227 stream.write_f32::<BigEndian>(*self)?;
228 Ok(())
229 }
230}
231impl Unpackable for f32 {
232 type Error = PackError;
233
234 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
235 Ok(rdr.read_f32::<BigEndian>()?)
236 }
237}
238
239impl Packable for f64 {
240 type Error = io::Error;
241
242 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
243 stream.write_f64::<BigEndian>(*self)?;
244 Ok(())
245 }
246}
247impl Unpackable for f64 {
248 type Error = PackError;
249
250 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
251 Ok(rdr.read_f64::<BigEndian>()?)
252 }
253}
254
255impl<T: Packable, const S: usize> Packable for [T; S] {
256 type Error = T::Error;
257
258 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
259 for v in self {
260 v.pack_into(stream)?;
261 }
262
263 Ok(())
264 }
265}
266impl<T: Unpackable, const S: usize> Unpackable for [T; S] {
267 type Error = T::Error;
268
269 fn unpack_from(rdr: &mut impl Read) -> Result<Self, Self::Error> {
270 let mut v: Vec<T> = Vec::with_capacity(S);
271
272 for _ in 0..S {
273 v.push(unpack_from(rdr)?);
274 }
275
276 Ok(v.try_into().unwrap_or_else(|_| unreachable!()))
277 }
278}
279
280impl<T: Packable> Packable for Vec<T> {
281 type Error = T::Error;
282
283 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
284 for v in self {
285 v.pack_into(stream)?;
286 }
287
288 Ok(())
289 }
290}
291
292impl<T: Packable> Packable for &T {
293 type Error = T::Error;
294
295 fn pack_into(&self, stream: &mut impl Write) -> Result<(), Self::Error> {
296 (*self).pack_into(stream)
297 }
298}
299
300pub fn unpack_from<T: Unpackable>(rdr: &mut impl Read) -> Result<T, T::Error> {
301 T::unpack_from(rdr)
302}
303pub fn unpack<'a, T: Unpackable>(buf: &'a [u8]) -> Result<(T, &'a [u8]), T::Error> {
304 T::unpack(buf)
305}
306
307pub fn pack_into<T: Packable>(wtr: &mut impl Write, value: &T) -> Result<(), T::Error> {
308 T::pack_into(value, wtr)
309}
310pub fn pack<T: Packable>(value: &T) -> Result<Vec<u8>, T::Error> {
311 T::pack(value)
312}
313
314pub trait WritePackExt: io::Write + Sized {
315 fn pack<T: Packable>(&mut self, pack: &T) -> Result<(), T::Error>;
316}
317impl<T: Write> WritePackExt for T {
318 fn pack<P: Packable>(&mut self, pack: &P) -> Result<(), P::Error> {
319 pack.pack_into(self)?;
320 Ok(())
321 }
322}
323
324pub trait ReadPackExt: io::Read {
325 fn unpack<T: Unpackable>(&mut self) -> Result<T, T::Error>;
326}
327impl<T: Read> ReadPackExt for T {
328 fn unpack<U: Unpackable>(&mut self) -> Result<U, U::Error> {
329 U::unpack_from(self)
330 }
331}
332
333#[cfg(test)]
334mod tests {
335 use crate::*;
336 #[test]
337 fn test_pack_bool() {
338 let t = true;
339 let f = false;
340 let tb = t.pack().unwrap();
341 let fb = f.pack().unwrap();
342
343 assert_eq!(tb, vec![0x01]);
344 assert_eq!(fb, vec![0x00]);
345 }
346
347 #[test]
348 fn test_unpack_bool() {
349 let tb1 = [];
350 let tb2 = [0x1];
351 let tb3 = [0x1, 0xff];
352 let tb4 = [0x20];
353 let tb5 = [0x20, 0xff];
354 let fb6 = [0];
355 let fb7 = [0, 0xff];
356
357 let tv1: Result<(i8, _), PackError> = unpack(&tb1);
358 let (tv2, tv2b): (bool, _) = unpack(&tb2).unwrap();
359 let (tv3, tv3b): (bool, _) = unpack(&tb3).unwrap();
360 let (tv4, tv4b): (bool, _) = unpack(&tb4).unwrap();
361 let (tv5, tv5b): (bool, _) = unpack(&tb5).unwrap();
362 let (fv6, fvb6): (bool, _) = unpack(&fb6).unwrap();
363 let (fv7, fvb7): (bool, _) = unpack(&fb7).unwrap();
364
365 assert_eq!(tv1, Err(PackError::SizeError));
366 assert_eq!(tv2, true);
367 assert_eq!(tv2b, &[]);
368 assert_eq!(tv3, true);
369 assert_eq!(tv3b, &[0xff]);
370 assert_eq!(tv4, true);
371 assert_eq!(tv4b, &[]);
372 assert_eq!(tv5, true);
373 assert_eq!(tv5b, &[0xff]);
374 assert_eq!(fv6, false);
375 assert_eq!(fvb6, &[]);
376 assert_eq!(fv7, false);
377 assert_eq!(fvb7, &[0xff]);
378 }
379
380 #[test]
381 fn test_roundtrip_bool() {
382 let v1 = true;
383 let v2 = false;
384
385 let i1 = v1.pack().unwrap();
386 let i2 = v2.pack().unwrap();
387
388 let (t1, t1b): (bool, _) = unpack(&i1).unwrap();
389 let (t2, t2b): (bool, _) = unpack(&i2).unwrap();
390
391 assert_eq!(t1, v1);
392 assert_eq!(t1b, &[]);
393 assert_eq!(t2, v2);
394 assert_eq!(t2b, &[]);
395 }
396
397 #[test]
398 fn test_pack_u8() {
399 let val = 0xfu8;
400
401 assert_eq!(val.pack().unwrap(), vec![val]);
402 }
403
404 #[test]
405 fn test_unpack_u8() {
406 let u1 = [];
407 let u2 = [0x82];
408 let u3 = [0x82, 0xff];
409
410 let v1: Result<(i8, _), PackError> = unpack(&u1);
411 let (v2, b2): (u8, _) = unpack(&u2).unwrap();
412 let (v3, b3): (u8, _) = unpack(&u3).unwrap();
413
414 assert_eq!(v1, Err(PackError::SizeError));
415 assert_eq!(v2, 0x82);
416 assert_eq!(b2, &[]);
417 assert_eq!(v3, 0x82);
418 assert_eq!(b3, &[0xff]);
419 }
420
421 #[test]
422 fn test_roundtrip_u8() {
423 let v = 0x20;
424
425 let i = v.pack().unwrap();
426
427 let (t, tb): (u8, _) = unpack(&i).unwrap();
428
429 assert_eq!(t, v);
430 assert_eq!(tb, &[]);
431 }
432
433 #[test]
434 fn test_pack_i8() {
435 let val = 25i8;
436 let val2 = -25i8;
437
438 assert_eq!(val.pack().unwrap(), vec![25]);
439 assert_eq!(val2.pack().unwrap(), vec![231]);
440 }
441
442 #[test]
443 fn test_unpack_i8() {
444 let i1 = [];
445 let i2 = [25];
446 let i3 = [25, 0xff];
447 let i4 = [231];
448 let i5 = [231, 0xff];
449
450 let v1: Result<(i8, _), PackError> = unpack(&i1);
451 let (v2, b2): (i8, _) = unpack(&i2).unwrap();
452 let (v3, b3): (i8, _) = unpack(&i3).unwrap();
453 let (v4, b4): (i8, _) = unpack(&i4).unwrap();
454 let (v5, b5): (i8, _) = unpack(&i5).unwrap();
455
456 assert_eq!(v1, Err(PackError::SizeError));
457 assert_eq!(v2, 25);
458 assert_eq!(b2, &[]);
459 assert_eq!(v3, 25);
460 assert_eq!(b3, &[0xff]);
461 assert_eq!(v4, -25);
462 assert_eq!(b4, &[]);
463 assert_eq!(v5, -25);
464 assert_eq!(b5, &[0xff]);
465 }
466
467 #[test]
468 fn test_roundtrip_i8() {
469 let v1 = 25;
470 let v2 = -25;
471
472 let i1 = v1.pack().unwrap();
473 let i2 = v2.pack().unwrap();
474
475 let (t1, t1b): (i8, _) = unpack(&i1).unwrap();
476 let (t2, t2b): (i8, _) = unpack(&i2).unwrap();
477
478 assert_eq!(t1, v1);
479 assert_eq!(t1b, &[]);
480 assert_eq!(t2, v2);
481 assert_eq!(t2b, &[]);
482 }
483
484 #[test]
485 fn test_pack_u16() {
486 let v1 = 0x1221u16;
487
488 assert_eq!(v1.pack().unwrap(), vec![0x12, 0x21]);
489 }
490
491 #[test]
492 fn test_unpack_u16() {
493 let i1 = [];
494 let i2 = [0x12];
495 let i3 = [0x12, 0x21];
496 let i4 = [0x12, 0x21, 0xff];
497
498 let v1: Result<(u16, _), PackError> = unpack(&i1);
499 let v2: Result<(u16, _), PackError> = unpack(&i2);
500 let (v3, b3): (u16, _) = unpack(&i3).unwrap();
501 let (v4, b4): (u16, _) = unpack(&i4).unwrap();
502
503 assert_eq!(v1, Err(PackError::SizeError));
504 assert_eq!(v2, Err(PackError::SizeError));
505 assert_eq!(v3, 0x1221);
506 assert_eq!(b3, &[]);
507 assert_eq!(v4, 0x1221);
508 assert_eq!(b4, &[0xff]);
509 }
510
511 #[test]
512 fn test_roundtrip_u16() {
513 let v1 = 0x1221u16;
514
515 let i1 = v1.pack().unwrap();
516
517 let (t1, t1b): (u16, _) = unpack(&i1).unwrap();
518
519 assert_eq!(t1, v1);
520 assert_eq!(t1b, &[]);
521 }
522
523 #[test]
524 fn test_pack_i16() {
525 let v1 = 0x1221i16;
526 let v2 = -0x1221i16;
527
528 assert_eq!(v1.pack().unwrap(), vec![0x12, 0x21]);
529 assert_eq!(v2.pack().unwrap(), vec![0xed, 0xdf]);
530 }
531
532 #[test]
533 fn test_unpack_i16() {
534 let i1 = [0x12];
535 let i2 = [0x12, 0x21];
536 let i3 = [0x12, 0x21, 0xff];
537 let i4 = [0xed, 0xdf];
538 let i5 = [0xed, 0xdf, 0xff];
539
540 let v1: Result<(i16, _), PackError> = unpack(&i1);
541 let (v2, b2): (i16, _) = unpack(&i2).unwrap();
542 let (v3, b3): (i16, _) = unpack(&i3).unwrap();
543 let (v4, b4): (i16, _) = unpack(&i4).unwrap();
544 let (v5, b5): (i16, _) = unpack(&i5).unwrap();
545
546 assert_eq!(v1, Err(PackError::SizeError));
547 assert_eq!(v2, 0x1221);
548 assert_eq!(b2, &[]);
549 assert_eq!(v3, 0x1221);
550 assert_eq!(b3, &[0xff]);
551 assert_eq!(v4, -0x1221);
552 assert_eq!(b4, &[]);
553 assert_eq!(v5, -0x1221);
554 assert_eq!(b5, &[0xff]);
555 }
556
557 #[test]
558 fn test_roundtrip_i16() {
559 let v1 = 0x1221;
560 let v2 = -0x1221;
561
562 let i1 = v1.pack().unwrap();
563 let i2 = v2.pack().unwrap();
564
565 let (t1, b1): (i16, _) = unpack(&i1).unwrap();
566 let (t2, b2): (i16, _) = unpack(&i2).unwrap();
567
568 assert_eq!(t1, v1);
569 assert_eq!(b1, &[]);
570 assert_eq!(t2, v2);
571 assert_eq!(b2, &[]);
572 }
573
574 #[test]
575 fn test_pack_u32() {
576 let v1 = 0x12345678u32;
577
578 assert_eq!(v1.pack().unwrap(), vec![0x12, 0x34, 0x56, 0x78]);
579 }
580
581 #[test]
582 fn test_unpack_u32() {
583 let i1 = [];
584 let i2 = [0x12];
585 let i3 = [0x12, 0x34];
586 let i4 = [0x12, 0x34, 0x56];
587 let i5 = [0x12, 0x34, 0x56, 0x78];
588 let i6 = [0x12, 0x34, 0x56, 0x78, 0xff];
589
590 let v1: Result<(u32, _), PackError> = unpack(&i1);
591 let v2: Result<(u32, _), PackError> = unpack(&i2);
592 let v3: Result<(u32, _), PackError> = unpack(&i3);
593 let v4: Result<(u32, _), PackError> = unpack(&i4);
594 let (v5, b5): (u32, _) = unpack(&i5).unwrap();
595 let (v6, b6): (u32, _) = unpack(&i6).unwrap();
596
597 assert_eq!(v1, Err(PackError::SizeError));
598 assert_eq!(v2, Err(PackError::SizeError));
599 assert_eq!(v3, Err(PackError::SizeError));
600 assert_eq!(v4, Err(PackError::SizeError));
601 assert_eq!(v5, 0x12345678);
602 assert_eq!(b5, &[]);
603 assert_eq!(v6, 0x12345678);
604 assert_eq!(b6, &[0xff]);
605 }
606
607 #[test]
608 fn test_roundtrip_u32() {
609 let v = 0x12345678u32;
610
611 let i = v.pack().unwrap();
612
613 let (t1, b1): (u32, _) = unpack(&i).unwrap();
614
615 assert_eq!(t1, v);
616 assert_eq!(b1, &[]);
617 }
618
619 #[test]
620 fn test_pack_i32() {
621 let v1 = 0x12345678i32;
622 let v2 = -0x12345678i32;
623
624 let i1 = v1.pack().unwrap();
625 let i2 = v2.pack().unwrap();
626
627 assert_eq!(i1, vec![0x12, 0x34, 0x56, 0x78]);
628 assert_eq!(i2, vec![0xed, 0xcb, 0xa9, 0x88]);
629 }
630
631 #[test]
632 fn test_unpack_i32() {
633 let i1 = [];
634 let i2 = [0x12];
635 let i3 = [0x12, 0x34];
636 let i4 = [0x12, 0x34, 0x56];
637 let i5 = [0x12, 0x34, 0x56, 0x78];
638 let i6 = [0x12, 0x34, 0x56, 0x78, 0xff];
639 let i7 = [0xed, 0xcb, 0xa9, 0x88];
640 let i8 = [0xed, 0xcb, 0xa9, 0x88, 0xff];
641
642 let v1: Result<(i32, _), PackError> = unpack(&i1);
643 let v2: Result<(i32, _), PackError> = unpack(&i2);
644 let v3: Result<(i32, _), PackError> = unpack(&i3);
645 let v4: Result<(i32, _), PackError> = unpack(&i4);
646 let (v5, b5): (i32, _) = unpack(&i5).unwrap();
647 let (v6, b6): (i32, _) = unpack(&i6).unwrap();
648 let (v7, b7): (i32, _) = unpack(&i7).unwrap();
649 let (v8, b8): (i32, _) = unpack(&i8).unwrap();
650
651 assert_eq!(v1, Err(PackError::SizeError));
652 assert_eq!(v2, Err(PackError::SizeError));
653 assert_eq!(v3, Err(PackError::SizeError));
654 assert_eq!(v4, Err(PackError::SizeError));
655 assert_eq!(v5, 0x12345678);
656 assert_eq!(b5, &[]);
657 assert_eq!(v6, 0x12345678);
658 assert_eq!(b6, &[0xff]);
659 assert_eq!(v7, -0x12345678);
660 assert_eq!(b7, &[]);
661 assert_eq!(v8, -0x12345678);
662 assert_eq!(b8, &[0xff]);
663 }
664
665 #[test]
666 fn test_roundtrip_i32() {
667 let v1 = 0x12345678;
668 let v2 = -0x12345678;
669
670 let i1 = v1.pack().unwrap();
671 let i2 = v2.pack().unwrap();
672
673 let (t1, b1): (i32, _) = unpack(&i1).unwrap();
674 let (t2, b2): (i32, _) = unpack(&i2).unwrap();
675
676 assert_eq!(t1, v1);
677 assert_eq!(b1, &[]);
678 assert_eq!(t2, v2);
679 assert_eq!(b2, &[]);
680 }
681
682 #[test]
683 fn test_pack_u64() {
684 let v1 = 0x0123456789abcdefu64;
685
686 assert_eq!(v1.pack().unwrap(), vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
687 }
688
689 #[test]
690 fn test_unpack_u64() {
691 let i1 = [];
692 let i2 = [0x01];
693 let i3 = [0x01, 0x23];
694 let i4 = [0x01, 0x23, 0x45];
695 let i5 = [0x01, 0x23, 0x45, 0x67];
696 let i6 = [0x01, 0x23, 0x45, 0x67, 0x89];
697 let i7 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab];
698 let i8 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd];
699 let i9 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
700 let i10 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff];
701
702 let v1: Result<(u64, _), PackError> = unpack(&i1);
703 let v2: Result<(u64, _), PackError> = unpack(&i2);
704 let v3: Result<(u64, _), PackError> = unpack(&i3);
705 let v4: Result<(u64, _), PackError> = unpack(&i4);
706 let v5: Result<(u64, _), PackError> = unpack(&i5);
707 let v6: Result<(u64, _), PackError> = unpack(&i6);
708 let v7: Result<(u64, _), PackError> = unpack(&i7);
709 let v8: Result<(u64, _), PackError> = unpack(&i8);
710 let (v9, b9): (u64, _) = unpack(&i9).unwrap();
711 let (v10, b10): (u64, _) = unpack(&i10).unwrap();
712
713 assert_eq!(v1, Err(PackError::SizeError));
714 assert_eq!(v2, Err(PackError::SizeError));
715 assert_eq!(v3, Err(PackError::SizeError));
716 assert_eq!(v4, Err(PackError::SizeError));
717 assert_eq!(v5, Err(PackError::SizeError));
718 assert_eq!(v6, Err(PackError::SizeError));
719 assert_eq!(v7, Err(PackError::SizeError));
720 assert_eq!(v8, Err(PackError::SizeError));
721 assert_eq!(v9, 0x0123456789abcdef);
722 assert_eq!(b9, &[]);
723 assert_eq!(v10, 0x0123456789abcdef);
724 assert_eq!(b10, &[0xff]);
725 }
726
727 #[test]
728 fn test_roundtrip_u64() {
729 let v = 0x0123456789abcdefu64;
730
731 let i = v.pack().unwrap();
732
733 let (t1, b1): (u64, _) = unpack(&i).unwrap();
734
735 assert_eq!(t1, v);
736 assert_eq!(b1, &[]);
737 }
738
739 #[test]
740 fn test_pack_i64() {
741 let v1 = 0x123456789abcdefi64;
742 let v2 = -0x123456789abcdefi64;
743
744 assert_eq!(v1.pack().unwrap(), vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
745 assert_eq!(v2.pack().unwrap(), vec![0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11]);
746 }
747
748 #[test]
749 fn test_unpack_i64() {
750 let i1 = [];
751 let i2 = [0x01];
752 let i3 = [0x01, 0x23];
753 let i4 = [0x01, 0x23, 0x45];
754 let i5 = [0x01, 0x23, 0x45, 0x67];
755 let i6 = [0x01, 0x23, 0x45, 0x67, 0x89];
756 let i7 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab];
757 let i8 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd];
758 let i9 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
759 let i10 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff];
760 let i11 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11];
761 let i12 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11, 0xff];
762
763 let v1: Result<(i64, _), PackError> = unpack(&i1);
764 let v2: Result<(i64, _), PackError> = unpack(&i2);
765 let v3: Result<(i64, _), PackError> = unpack(&i3);
766 let v4: Result<(i64, _), PackError> = unpack(&i4);
767 let v5: Result<(i64, _), PackError> = unpack(&i5);
768 let v6: Result<(i64, _), PackError> = unpack(&i6);
769 let v7: Result<(i64, _), PackError> = unpack(&i7);
770 let v8: Result<(i64, _), PackError> = unpack(&i8);
771 let (v9, b9): (i64, _) = unpack(&i9).unwrap();
772 let (v10, b10): (i64, _) = unpack(&i10).unwrap();
773 let (v11, b11): (i64, _) = unpack(&i11).unwrap();
774 let (v12, b12): (i64, _) = unpack(&i12).unwrap();
775
776 assert_eq!(v1, Err(PackError::SizeError));
777 assert_eq!(v2, Err(PackError::SizeError));
778 assert_eq!(v3, Err(PackError::SizeError));
779 assert_eq!(v4, Err(PackError::SizeError));
780 assert_eq!(v5, Err(PackError::SizeError));
781 assert_eq!(v6, Err(PackError::SizeError));
782 assert_eq!(v7, Err(PackError::SizeError));
783 assert_eq!(v8, Err(PackError::SizeError));
784 assert_eq!(v9, 0x0123456789abcdef);
785 assert_eq!(b9, &[]);
786 assert_eq!(v10, 0x0123456789abcdef);
787 assert_eq!(b10, &[0xff]);
788 assert_eq!(v11, -0x0123456789abcdef);
789 assert_eq!(b11, &[]);
790 assert_eq!(v12, -0x0123456789abcdef);
791 assert_eq!(b12, &[0xff]);
792 }
793
794 #[test]
795 fn test_roundtrip_i64() {
796 let v1 = 0x123456789abcdefi64;
797 let v2 = -0x123456789abcdefi64;
798
799 let i1 = v1.pack().unwrap();
800 let i2 = v2.pack().unwrap();
801
802 let (t1, b1): (i64, _) = unpack(&i1).unwrap();
803 let (t2, b2): (i64, _) = unpack(&i2).unwrap();
804
805 assert_eq!(t1, v1);
806 assert_eq!(b1, &[]);
807 assert_eq!(t2, v2);
808 assert_eq!(b2, &[]);
809 }
810
811 #[test]
812 fn test_pack_u128() {
813 let v1 = 0x0123456789abcdeffedcba9876543210u128;
814
815 assert_eq!(v1.pack().unwrap(), vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10]);
816 }
817
818 #[test]
819 fn test_unpack_u128() {
820 let i1 = [];
821 let i2 = [0x01];
822 let i3 = [0x01, 0x23];
823 let i4 = [0x01, 0x23, 0x45];
824 let i5 = [0x01, 0x23, 0x45, 0x67];
825 let i6 = [0x01, 0x23, 0x45, 0x67, 0x89];
826 let i7 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab];
827 let i8 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd];
828 let i9 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
829 let i10 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe];
830 let i11 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc];
831 let i12 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba];
832 let i13 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98];
833 let i14 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76];
834 let i15 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54];
835 let i16 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32];
836 let i17 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10];
837 let i18 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0xff];
838
839 let v1: Result<(u128, _), PackError> = unpack(&i1);
840 let v2: Result<(u128, _), PackError> = unpack(&i2);
841 let v3: Result<(u128, _), PackError> = unpack(&i3);
842 let v4: Result<(u128, _), PackError> = unpack(&i4);
843 let v5: Result<(u128, _), PackError> = unpack(&i5);
844 let v6: Result<(u128, _), PackError> = unpack(&i6);
845 let v7: Result<(u128, _), PackError> = unpack(&i7);
846 let v8: Result<(u128, _), PackError> = unpack(&i8);
847 let v9: Result<(u128, _), PackError> = unpack(&i9);
848 let v10: Result<(u128, _), PackError> = unpack(&i10);
849 let v11: Result<(u128, _), PackError> = unpack(&i11);
850 let v12: Result<(u128, _), PackError> = unpack(&i12);
851 let v13: Result<(u128, _), PackError> = unpack(&i13);
852 let v14: Result<(u128, _), PackError> = unpack(&i14);
853 let v15: Result<(u128, _), PackError> = unpack(&i15);
854 let v16: Result<(u128, _), PackError> = unpack(&i16);
855 let (v17, b17): (u128, _) = unpack(&i17).unwrap();
856 let (v18, b18): (u128, _) = unpack(&i18).unwrap();
857
858 assert_eq!(v1, Err(PackError::SizeError));
859 assert_eq!(v2, Err(PackError::SizeError));
860 assert_eq!(v3, Err(PackError::SizeError));
861 assert_eq!(v4, Err(PackError::SizeError));
862 assert_eq!(v5, Err(PackError::SizeError));
863 assert_eq!(v6, Err(PackError::SizeError));
864 assert_eq!(v7, Err(PackError::SizeError));
865 assert_eq!(v8, Err(PackError::SizeError));
866 assert_eq!(v9, Err(PackError::SizeError));
867 assert_eq!(v10, Err(PackError::SizeError));
868 assert_eq!(v11, Err(PackError::SizeError));
869 assert_eq!(v12, Err(PackError::SizeError));
870 assert_eq!(v13, Err(PackError::SizeError));
871 assert_eq!(v14, Err(PackError::SizeError));
872 assert_eq!(v15, Err(PackError::SizeError));
873 assert_eq!(v16, Err(PackError::SizeError));
874 assert_eq!(v17, 0x0123456789abcdeffedcba9876543210);
875 assert_eq!(b17, &[]);
876 assert_eq!(v18, 0x0123456789abcdeffedcba9876543210);
877 assert_eq!(b18, &[0xff]);
878 }
879
880 #[test]
881 fn test_roundtrip_u128() {
882 let v = 0x0123456789abcdeffedcba9876543210u128;
883
884 let i = v.pack().unwrap();
885
886 let (t1, b1): (u128, _) = unpack(&i).unwrap();
887
888 assert_eq!(t1, v);
889 assert_eq!(b1, &[]);
890 }
891
892 #[test]
893 fn test_pack_i128() {
894 let v1 = 0x0123456789abcdeffedcba9876543210i128;
895 let v2 = -0x0123456789abcdeffedcba9876543210i128;
896
897 assert_eq!(v1.pack().unwrap(), vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10]);
898 assert_eq!(v2.pack().unwrap(), vec![0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xf0]);
899 }
900
901 #[test]
902 fn test_unpack_i128() {
903 let i1 = [];
904 let i2 = [0x01];
905 let i3 = [0x01, 0x23];
906 let i4 = [0x01, 0x23, 0x45];
907 let i5 = [0x01, 0x23, 0x45, 0x67];
908 let i6 = [0x01, 0x23, 0x45, 0x67, 0x89];
909 let i7 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab];
910 let i8 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd];
911 let i9 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
912 let i10 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe];
913 let i11 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc];
914 let i12 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba];
915 let i13 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98];
916 let i14 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76];
917 let i15 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54];
918 let i16 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32];
919 let i17 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10];
920 let i18 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0xff];
921 let i19 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xf0];
922 let i20 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xf0, 0xff];
923
924 let v1: Result<(i128, _), PackError> = unpack(&i1);
925 let v2: Result<(i128, _), PackError> = unpack(&i2);
926 let v3: Result<(i128, _), PackError> = unpack(&i3);
927 let v4: Result<(i128, _), PackError> = unpack(&i4);
928 let v5: Result<(i128, _), PackError> = unpack(&i5);
929 let v6: Result<(i128, _), PackError> = unpack(&i6);
930 let v7: Result<(i128, _), PackError> = unpack(&i7);
931 let v8: Result<(i128, _), PackError> = unpack(&i8);
932 let v9: Result<(i128, _), PackError> = unpack(&i9);
933 let v10: Result<(i128, _), PackError> = unpack(&i10);
934 let v11: Result<(i128, _), PackError> = unpack(&i11);
935 let v12: Result<(i128, _), PackError> = unpack(&i12);
936 let v13: Result<(i128, _), PackError> = unpack(&i13);
937 let v14: Result<(i128, _), PackError> = unpack(&i14);
938 let v15: Result<(i128, _), PackError> = unpack(&i15);
939 let v16: Result<(i128, _), PackError> = unpack(&i16);
940 let (v17, b17): (i128, _) = unpack(&i17).unwrap();
941 let (v18, b18): (i128, _) = unpack(&i18).unwrap();
942 let (v19, b19): (i128, _) = unpack(&i19).unwrap();
943 let (v20, b20): (i128, _) = unpack(&i20).unwrap();
944
945 assert_eq!(v1, Err(PackError::SizeError));
946 assert_eq!(v2, Err(PackError::SizeError));
947 assert_eq!(v3, Err(PackError::SizeError));
948 assert_eq!(v4, Err(PackError::SizeError));
949 assert_eq!(v5, Err(PackError::SizeError));
950 assert_eq!(v6, Err(PackError::SizeError));
951 assert_eq!(v7, Err(PackError::SizeError));
952 assert_eq!(v8, Err(PackError::SizeError));
953 assert_eq!(v9, Err(PackError::SizeError));
954 assert_eq!(v10, Err(PackError::SizeError));
955 assert_eq!(v11, Err(PackError::SizeError));
956 assert_eq!(v12, Err(PackError::SizeError));
957 assert_eq!(v13, Err(PackError::SizeError));
958 assert_eq!(v14, Err(PackError::SizeError));
959 assert_eq!(v15, Err(PackError::SizeError));
960 assert_eq!(v16, Err(PackError::SizeError));
961 assert_eq!(v17, 0x0123456789abcdeffedcba9876543210);
962 assert_eq!(b17, &[]);
963 assert_eq!(v18, 0x0123456789abcdeffedcba9876543210);
964 assert_eq!(b18, &[0xff]);
965 assert_eq!(v19, -0x0123456789abcdeffedcba9876543210);
966 assert_eq!(b19, &[]);
967 assert_eq!(v20, -0x0123456789abcdeffedcba9876543210);
968 assert_eq!(b20, &[0xff]);
969 }
970
971 #[test]
972 fn test_roundtrip_i128() {
973 let v1 = 0x0123456789abcdeffedcba9876543210i128;
974 let v2 = -0x0123456789abcdeffedcba9876543210i128;
975
976 let i1 = v1.pack().unwrap();
977 let i2 = v2.pack().unwrap();
978
979 let (t1, b1): (i128, _) = unpack(&i1).unwrap();
980 let (t2, b2): (i128, _) = unpack(&i2).unwrap();
981
982 assert_eq!(t1, v1);
983 assert_eq!(b1, &[]);
984 assert_eq!(t2, v2);
985 assert_eq!(b2, &[]);
986 }
987
988 #[test]
989 fn test_pack_f32() {
990 let v1 = 0.00000000000000000000000000056904566f32;
991 let v2 = -7878801000000000000000000000.0f32;
992
993 assert_eq!(v1.pack().unwrap(), &[0x12, 0x34, 0x56, 0x78]);
994 assert_eq!(v2.pack().unwrap(), &[0xed, 0xcb, 0xa9, 0x88]);
995 }
996
997 #[test]
998 fn test_unpack_f32() {
999 let i1 = [];
1000 let i2 = [0x12];
1001 let i3 = [0x12, 0x34];
1002 let i4 = [0x12, 0x34, 0x56];
1003 let i5 = [0x12, 0x34, 0x56, 0x78];
1004 let i6 = [0x12, 0x34, 0x56, 0x78, 0xff];
1005 let i7 = [0xed, 0xcb, 0xa9, 0x88];
1006 let i8 = [0xed, 0xcb, 0xa9, 0x88, 0xff];
1007
1008 let v1: Result<(f32, _), PackError> = unpack(&i1);
1009 let v2: Result<(f32, _), PackError> = unpack(&i2);
1010 let v3: Result<(f32, _), PackError> = unpack(&i3);
1011 let v4: Result<(f32, _), PackError> = unpack(&i4);
1012 let (v5, b5): (f32, _) = unpack(&i5).unwrap();
1013 let (v6, b6): (f32, _) = unpack(&i6).unwrap();
1014 let (v7, b7): (f32, _) = unpack(&i7).unwrap();
1015 let (v8, b8): (f32, _) = unpack(&i8).unwrap();
1016
1017 assert_eq!(v1, Err(PackError::SizeError));
1018 assert_eq!(v2, Err(PackError::SizeError));
1019 assert_eq!(v3, Err(PackError::SizeError));
1020 assert_eq!(v4, Err(PackError::SizeError));
1021 assert_eq!(v5, 0.00000000000000000000000000056904566);
1022 assert_eq!(b5, &[]);
1023 assert_eq!(v6, 0.00000000000000000000000000056904566);
1024 assert_eq!(b6, &[0xff]);
1025 assert_eq!(v7, -7878801000000000000000000000.0);
1026 assert_eq!(b7, &[]);
1027 assert_eq!(v8, -7878801000000000000000000000.0);
1028 assert_eq!(b8, &[0xff]);
1029 }
1030
1031 #[test]
1032 fn test_roundtrip_f32() {
1033 let v1 = 0.00000000000000000000000000056904566f32;
1034 let v2 = -7878801000000000000000000000.0f32;
1035
1036 let i1 = v1.pack().unwrap();
1037 let i2 = v2.pack().unwrap();
1038
1039 let (t1, b1): (f32, _) = unpack(&i1).unwrap();
1040 let (t2, b2): (f32, _) = unpack(&i2).unwrap();
1041
1042 assert_eq!(t1, v1);
1043 assert_eq!(b1, &[]);
1044 assert_eq!(t2, v2);
1045 assert_eq!(b2, &[]);
1046 }
1047
1048 #[test]
1049 fn test_pack_f64() {
1050 let v1 = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003512700564088504;
1051 let v2 = -1231330068773694700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0;
1052
1053 assert_eq!(v1.pack().unwrap(), vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
1054 assert_eq!(v2.pack().unwrap(), vec![0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11]);
1055 }
1056
1057 #[test]
1058 fn test_unpack_f64() {
1059 let i1 = [];
1060 let i2 = [0x01];
1061 let i3 = [0x01, 0x23];
1062 let i4 = [0x01, 0x23, 0x45];
1063 let i5 = [0x01, 0x23, 0x45, 0x67];
1064 let i6 = [0x01, 0x23, 0x45, 0x67, 0x89];
1065 let i7 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab];
1066 let i8 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd];
1067 let i9 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
1068 let i10 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff];
1069 let i11 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11];
1070 let i12 = [0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x11, 0xff];
1071
1072 let v1: Result<(f64, _), PackError> = unpack(&i1);
1073 let v2: Result<(f64, _), PackError> = unpack(&i2);
1074 let v3: Result<(f64, _), PackError> = unpack(&i3);
1075 let v4: Result<(f64, _), PackError> = unpack(&i4);
1076 let v5: Result<(f64, _), PackError> = unpack(&i5);
1077 let v6: Result<(f64, _), PackError> = unpack(&i6);
1078 let v7: Result<(f64, _), PackError> = unpack(&i7);
1079 let v8: Result<(f64, _), PackError> = unpack(&i8);
1080 let (v9, b9): (f64, _) = unpack(&i9).unwrap();
1081 let (v10, b10): (f64, _) = unpack(&i10).unwrap();
1082 let (v11, b11): (f64, _) = unpack(&i11).unwrap();
1083 let (v12, b12): (f64, _) = unpack(&i12).unwrap();
1084
1085 assert_eq!(v1, Err(PackError::SizeError));
1086 assert_eq!(v2, Err(PackError::SizeError));
1087 assert_eq!(v3, Err(PackError::SizeError));
1088 assert_eq!(v4, Err(PackError::SizeError));
1089 assert_eq!(v5, Err(PackError::SizeError));
1090 assert_eq!(v6, Err(PackError::SizeError));
1091 assert_eq!(v7, Err(PackError::SizeError));
1092 assert_eq!(v8, Err(PackError::SizeError));
1093 assert_eq!(v9, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003512700564088504);
1094 assert_eq!(b9, &[]);
1095 assert_eq!(v10, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003512700564088504);
1096 assert_eq!(b10, &[0xff]);
1097 assert_eq!(v11, -1231330068773694700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
1098 assert_eq!(b11, &[]);
1099 assert_eq!(v12, -1231330068773694700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
1100 assert_eq!(b12, &[0xff]);
1101 }
1102
1103 #[test]
1104 fn test_roundtrip_f64() {
1105 let v1 = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003512700564088504;
1106 let v2 = -1231330068773694700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0;
1107
1108 let i1 = v1.pack().unwrap();
1109 let i2 = v2.pack().unwrap();
1110
1111 let (t1, b1): (f64, _) = unpack(&i1).unwrap();
1112 let (t2, b2): (f64, _) = unpack(&i2).unwrap();
1113
1114 assert_eq!(t1, v1);
1115 assert_eq!(b1, &[]);
1116 assert_eq!(t2, v2);
1117 assert_eq!(b2, &[]);
1118 }
1119
1120 #[test]
1121 fn test_pack_array() {
1122 let a1: [u8; 0] = [];
1123 let a2: [u8; 1] = [0x01];
1124 let a3: [u8; 2] = [0x01, 0x23];
1125 let a4: [u16; 3] = [0x01, 0x23, 0x45];
1126
1127 assert_eq!(a1.pack().unwrap(), &a1);
1128 assert_eq!(a2.pack().unwrap(), &a2);
1129 assert_eq!(a3.pack().unwrap(), &a3);
1130 assert_eq!(a4.pack().unwrap(), &[0x00, 0x01, 0x00, 0x23, 0x00, 0x45]);
1131 }
1132
1133 #[test]
1134 fn test_unpack_array() {
1135 let a1 = [];
1136 let a2 = [0x01];
1137 let a3 = [0x01, 0x23];
1138 let a4 = [0x00, 0x01, 0x00, 0x23, 0x00];
1139 let a5 = [0x00, 0x01, 0x00, 0x23, 0x00, 0x45];
1140 let a6 = [0x00, 0x01, 0x00, 0x23, 0x00, 0x45, 0xff];
1141 let a7 = [0x01, 0xff];
1142
1143 let (v1, b1): ([u8; 0], _) = unpack(&a1).unwrap();
1144 let (v2, b2): ([u8; 1], _) = unpack(&a2).unwrap();
1145 let (v3, b3): ([u8; 2], _) = unpack(&a3).unwrap();
1146 let v4: Result<([u16; 3], _), PackError> = unpack(&a4);
1147 let (v5, b5): ([u16; 3], _) = unpack(&a5).unwrap();
1148 let (v6, b6): ([u16; 3], _) = unpack(&a6).unwrap();
1149 let (v7, b7): ([u8; 1], _) = unpack(&a7).unwrap();
1150
1151 assert_eq!(v1, []);
1152 assert_eq!(b1, &[]);
1153 assert_eq!(v2, [0x01]);
1154 assert_eq!(b2, &[]);
1155 assert_eq!(v3, [0x01, 0x23]);
1156 assert_eq!(b3, &[]);
1157 assert_eq!(v4, Err(PackError::SizeError));
1158 assert_eq!(v5, [0x01, 0x23, 0x45]);
1159 assert_eq!(b5, &[]);
1160 assert_eq!(v6, [0x01, 0x23, 0x45]);
1161 assert_eq!(b6, &[0xff]);
1162 assert_eq!(v7, [0x01]);
1163 assert_eq!(b7, &[0xff]);
1164 }
1165
1166 #[test]
1167 fn test_pack_vec() {
1168 let v1: Vec<u8> = vec![0x01, 0x23, 0x45];
1169 let v2: Vec<u16> = vec![0x0123, 0x4567];
1170
1171 assert_eq!(v1.pack().unwrap(), [0x01, 0x23, 0x45]);
1172 assert_eq!(v2.pack().unwrap(), [0x01, 0x23, 0x45, 0x67]);
1173 }
1174}