compiler/rustc_serialize/tests/opaque.rs

   1 #![allow(rustc::internal)]
   2
   3 use rustc_macros::{Decodable, Encodable};
   4 use rustc_serialize::opaque::{MemDecoder, MemEncoder};
   5 use rustc_serialize::{Decodable, Encodable};
   6 use std::fmt::Debug;
   7
   8 #[derive(PartialEq, Clone, Debug, Encodable, Decodable)]
   9 struct Struct {
  10     a: (),
  11     b: u8,
  12     c: u16,
  13     d: u32,
  14     e: u64,
  15     f: usize,
  16
  17     g: i8,
  18     h: i16,
  19     i: i32,
  20     j: i64,
  21     k: isize,
  22
  23     l: char,
  24     m: String,
  25     n: f32,
  26     o: f64,
  27     p: bool,
  28     q: Option<u32>,
  29 }
  30
  31 fn check_round_trip<
  32     T: Encodable<MemEncoder> + for<'a> Decodable<MemDecoder<'a>> + PartialEq + Debug,
  33 >(
  34     values: Vec<T>,
  35 ) {
  36     let mut encoder = MemEncoder::new();
  37     for value in &values {
  38         Encodable::encode(value, &mut encoder);
  39     }
  40
  41     let data = encoder.finish();
  42     let mut decoder = MemDecoder::new(&data[..], 0);
  43
  44     for value in values {
  45         let decoded = Decodable::decode(&mut decoder);
  46         assert_eq!(value, decoded);
  47     }
  48 }
  49
  50 #[test]
  51 fn test_unit() {
  52     check_round_trip(vec![(), (), (), ()]);
  53 }
  54
  55 #[test]
  56 fn test_u8() {
  57     let mut vec = vec![];
  58     for i in u8::MIN..u8::MAX {
  59         vec.push(i);
  60     }
  61     check_round_trip(vec);
  62 }
  63
  64 #[test]
  65 fn test_u16() {
  66     for i in u16::MIN..u16::MAX {
  67         check_round_trip(vec![1, 2, 3, i, i, i]);
  68     }
  69 }
  70
  71 #[test]
  72 fn test_u32() {
  73     check_round_trip(vec![1, 2, 3, u32::MIN, 0, 1, u32::MAX, 2, 1]);
  74 }
  75
  76 #[test]
  77 fn test_u64() {
  78     check_round_trip(vec![1, 2, 3, u64::MIN, 0, 1, u64::MAX, 2, 1]);
  79 }
  80
  81 #[test]
  82 fn test_usize() {
  83     check_round_trip(vec![1, 2, 3, usize::MIN, 0, 1, usize::MAX, 2, 1]);
  84 }
  85
  86 #[test]
  87 fn test_i8() {
  88     let mut vec = vec![];
  89     for i in i8::MIN..i8::MAX {
  90         vec.push(i);
  91     }
  92     check_round_trip(vec);
  93 }
  94
  95 #[test]
  96 fn test_i16() {
  97     for i in i16::MIN..i16::MAX {
  98         check_round_trip(vec![-1, 2, -3, i, i, i, 2]);
  99     }
 100 }
 101
 102 #[test]
 103 fn test_i32() {
 104     check_round_trip(vec![-1, 2, -3, i32::MIN, 0, 1, i32::MAX, 2, 1]);
 105 }
 106
 107 #[test]
 108 fn test_i64() {
 109     check_round_trip(vec![-1, 2, -3, i64::MIN, 0, 1, i64::MAX, 2, 1]);
 110 }
 111
 112 #[test]
 113 fn test_isize() {
 114     check_round_trip(vec![-1, 2, -3, isize::MIN, 0, 1, isize::MAX, 2, 1]);
 115 }
 116
 117 #[test]
 118 fn test_bool() {
 119     check_round_trip(vec![false, true, true, false, false]);
 120 }
 121
 122 #[test]
 123 fn test_f32() {
 124     let mut vec = vec![];
 125     for i in -100..100 {
 126         vec.push((i as f32) / 3.0);
 127     }
 128     check_round_trip(vec);
 129 }
 130
 131 #[test]
 132 fn test_f64() {
 133     let mut vec = vec![];
 134     for i in -100..100 {
 135         vec.push((i as f64) / 3.0);
 136     }
 137     check_round_trip(vec);
 138 }
 139
 140 #[test]
 141 fn test_char() {
 142     let vec = vec!['a', 'b', 'c', 'd', 'A', 'X', ' ', '#', 'Ö', 'Ä', 'µ', '€'];
 143     check_round_trip(vec);
 144 }
 145
 146 #[test]
 147 fn test_string() {
 148     let vec = vec![
 149         "abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
 150         "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
 151         "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(),
 152         "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(),
 153         "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
 154         "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(),
 155         "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string(),
 156     ];
 157
 158     check_round_trip(vec);
 159 }
 160
 161 #[test]
 162 fn test_option() {
 163     check_round_trip(vec![Some(-1i8)]);
 164     check_round_trip(vec![Some(-2i16)]);
 165     check_round_trip(vec![Some(-3i32)]);
 166     check_round_trip(vec![Some(-4i64)]);
 167     check_round_trip(vec![Some(-5isize)]);
 168
 169     let none_i8: Option<i8> = None;
 170     check_round_trip(vec![none_i8]);
 171
 172     let none_i16: Option<i16> = None;
 173     check_round_trip(vec![none_i16]);
 174
 175     let none_i32: Option<i32> = None;
 176     check_round_trip(vec![none_i32]);
 177
 178     let none_i64: Option<i64> = None;
 179     check_round_trip(vec![none_i64]);
 180
 181     let none_isize: Option<isize> = None;
 182     check_round_trip(vec![none_isize]);
 183 }
 184
 185 #[test]
 186 fn test_struct() {
 187     check_round_trip(vec![Struct {
 188         a: (),
 189         b: 10,
 190         c: 11,
 191         d: 12,
 192         e: 13,
 193         f: 14,
 194
 195         g: 15,
 196         h: 16,
 197         i: 17,
 198         j: 18,
 199         k: 19,
 200
 201         l: 'x',
 202         m: "abc".to_string(),
 203         n: 20.5,
 204         o: 21.5,
 205         p: false,
 206         q: None,
 207     }]);
 208
 209     check_round_trip(vec![Struct {
 210         a: (),
 211         b: 101,
 212         c: 111,
 213         d: 121,
 214         e: 131,
 215         f: 141,
 216
 217         g: -15,
 218         h: -16,
 219         i: -17,
 220         j: -18,
 221         k: -19,
 222
 223         l: 'y',
 224         m: "def".to_string(),
 225         n: -20.5,
 226         o: -21.5,
 227         p: true,
 228         q: Some(1234567),
 229     }]);
 230 }
 231
 232 #[derive(PartialEq, Clone, Debug, Encodable, Decodable)]
 233 enum Enum {
 234     Variant1,
 235     Variant2(usize, f32),
 236     Variant3 { a: i32, b: char, c: bool },
 237 }
 238
 239 #[test]
 240 fn test_enum() {
 241     check_round_trip(vec![
 242         Enum::Variant1,
 243         Enum::Variant2(1, 2.5),
 244         Enum::Variant3 { a: 3, b: 'b', c: false },
 245         Enum::Variant3 { a: -4, b: 'f', c: true },
 246     ]);
 247 }
 248
 249 #[test]
 250 fn test_sequence() {
 251     let mut vec = vec![];
 252     for i in -100i64..100i64 {
 253         vec.push(i * 100000);
 254     }
 255
 256     check_round_trip(vec![vec]);
 257 }
 258
 259 #[test]
 260 fn test_hash_map() {
 261     use std::collections::HashMap;
 262     let mut map = HashMap::new();
 263     for i in -100i64..100i64 {
 264         map.insert(i * 100000, i * 10000);
 265     }
 266
 267     check_round_trip(vec![map]);
 268 }
 269
 270 #[test]
 271 fn test_tuples() {
 272     check_round_trip(vec![('x', (), false, 0.5f32)]);
 273     check_round_trip(vec![(9i8, 10u16, 1.5f64)]);
 274     check_round_trip(vec![(-12i16, 11u8, 12usize)]);
 275     check_round_trip(vec![(1234567isize, 100000000000000u64, 99999999999999i64)]);
 276     check_round_trip(vec![(String::new(), "some string".to_string())]);
 277 }