compiler/rustc_serialize/tests/leb128.rs

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