compiler/rustc_serialize/tests/leb128.rs

   1 #![feature(int_bits_const)]
   2 #![feature(maybe_uninit_slice)]
   3 #![feature(maybe_uninit_uninit_array)]
   4
   5 use rustc_serialize::leb128::*;
   6 use std::mem::MaybeUninit;
   7
   8 macro_rules! impl_test_unsigned_leb128 {
   9     ($test_name:ident, $write_fn_name:ident, $read_fn_name:ident, $int_ty:ident) => {
  10         #[test]
  11         fn $test_name() {
  12             // Test 256 evenly spaced values of integer range,
  13             // integer max value, and some "random" numbers.
  14             let mut values = Vec::new();
  15
  16             let increment = (1 as $int_ty) << ($int_ty::BITS - 8);
  17             values.extend((0..256).map(|i| $int_ty::MIN + i * increment));
  18
  19             values.push($int_ty::MAX);
  20
  21             values.extend(
  22                 (-500..500).map(|i| (i as $int_ty).wrapping_mul(0x12345789ABCDEFu64 as $int_ty)),
  23             );
  24
  25             let mut stream = Vec::new();
  26
  27             for &x in &values {
  28                 let mut buf = MaybeUninit::uninit_array();
  29                 stream.extend($write_fn_name(&mut buf, x));
  30             }
  31
  32             let mut position = 0;
  33             for &expected in &values {
  34                 let (actual, bytes_read) = $read_fn_name(&stream[position..]);
  35                 assert_eq!(expected, actual);
  36                 position += bytes_read;
  37             }
  38             assert_eq!(stream.len(), position);
  39         }
  40     };
  41 }
  42
  43 impl_test_unsigned_leb128!(test_u16_leb128, write_u16_leb128, read_u16_leb128, u16);
  44 impl_test_unsigned_leb128!(test_u32_leb128, write_u32_leb128, read_u32_leb128, u32);
  45 impl_test_unsigned_leb128!(test_u64_leb128, write_u64_leb128, read_u64_leb128, u64);
  46 impl_test_unsigned_leb128!(test_u128_leb128, write_u128_leb128, read_u128_leb128, u128);
  47 impl_test_unsigned_leb128!(test_usize_leb128, write_usize_leb128, read_usize_leb128, usize);
  48
  49 macro_rules! impl_test_signed_leb128 {
  50     ($test_name:ident, $write_fn_name:ident, $read_fn_name:ident, $int_ty:ident) => {
  51         #[test]
  52         fn $test_name() {
  53             // Test 256 evenly spaced values of integer range,
  54             // integer max value, and some "random" numbers.
  55             let mut values = Vec::new();
  56
  57             let mut value = $int_ty::MIN;
  58             let increment = (1 as $int_ty) << ($int_ty::BITS - 8);
  59
  60             for _ in 0..256 {
  61                 values.push(value);
  62                 // The addition in the last loop iteration overflows.
  63                 value = value.wrapping_add(increment);
  64             }
  65
  66             values.push($int_ty::MAX);
  67
  68             values.extend(
  69                 (-500..500).map(|i| (i as $int_ty).wrapping_mul(0x12345789ABCDEFi64 as $int_ty)),
  70             );
  71
  72             let mut stream = Vec::new();
  73
  74             for &x in &values {
  75                 let mut buf = MaybeUninit::uninit_array();
  76                 stream.extend($write_fn_name(&mut buf, x));
  77             }
  78
  79             let mut position = 0;
  80             for &expected in &values {
  81                 let (actual, bytes_read) = $read_fn_name(&stream[position..]);
  82                 assert_eq!(expected, actual);
  83                 position += bytes_read;
  84             }
  85             assert_eq!(stream.len(), position);
  86         }
  87     };
  88 }
  89
  90 impl_test_signed_leb128!(test_i16_leb128, write_i16_leb128, read_i16_leb128, i16);
  91 impl_test_signed_leb128!(test_i32_leb128, write_i32_leb128, read_i32_leb128, i32);
  92 impl_test_signed_leb128!(test_i64_leb128, write_i64_leb128, read_i64_leb128, i64);
  93 impl_test_signed_leb128!(test_i128_leb128, write_i128_leb128, read_i128_leb128, i128);
  94 impl_test_signed_leb128!(test_isize_leb128, write_isize_leb128, read_isize_leb128, isize);