vendor/generic-array/tests/mod.rs

   1 #![recursion_limit = "128"]
   2 #![no_std]
   3 #[macro_use]
   4 extern crate generic_array;
   5 use core::cell::Cell;
   6 use core::ops::{Add, Drop};
   7 use generic_array::GenericArray;
   8 use generic_array::functional::*;
   9 use generic_array::sequence::*;
  10 use generic_array::typenum::{U1, U3, U4, U97};
  11
  12 #[test]
  13 fn test() {
  14     let mut list97 = [0; 97];
  15     for i in 0..97 {
  16         list97[i] = i as i32;
  17     }
  18     let l: GenericArray<i32, U97> = GenericArray::clone_from_slice(&list97);
  19     assert_eq!(l[0], 0);
  20     assert_eq!(l[1], 1);
  21     assert_eq!(l[32], 32);
  22     assert_eq!(l[56], 56);
  23 }
  24
  25 #[test]
  26 fn test_drop() {
  27     #[derive(Clone)]
  28     struct TestDrop<'a>(&'a Cell<u32>);
  29
  30     impl<'a> Drop for TestDrop<'a> {
  31         fn drop(&mut self) {
  32             self.0.set(self.0.get() + 1);
  33         }
  34     }
  35
  36     let drop_counter = Cell::new(0);
  37     {
  38         let _: GenericArray<TestDrop, U3> = arr![TestDrop; TestDrop(&drop_counter),
  39                            TestDrop(&drop_counter),
  40                            TestDrop(&drop_counter)];
  41     }
  42     assert_eq!(drop_counter.get(), 3);
  43 }
  44
  45 #[test]
  46 fn test_arr() {
  47     let test: GenericArray<u32, U3> = arr![u32; 1, 2, 3];
  48     assert_eq!(test[1], 2);
  49 }
  50
  51 #[test]
  52 fn test_copy() {
  53     let test = arr![u32; 1, 2, 3];
  54     let test2 = test;
  55     // if GenericArray is not copy, this should fail as a use of a moved value
  56     assert_eq!(test[1], 2);
  57     assert_eq!(test2[0], 1);
  58 }
  59
  60 #[derive(Debug, PartialEq, Eq)]
  61 struct NoClone<T>(T);
  62
  63 #[test]
  64 fn test_from_slice() {
  65     let arr = [1, 2, 3, 4];
  66     let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
  67     assert_eq!(&arr[..3], gen_arr.as_slice());
  68     let arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
  69     let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
  70     assert_eq!(&arr[..3], gen_arr.as_slice());
  71 }
  72
  73 #[test]
  74 fn test_from_mut_slice() {
  75     let mut arr = [1, 2, 3, 4];
  76     {
  77         let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
  78         gen_arr[2] = 10;
  79     }
  80     assert_eq!(arr, [1, 2, 10, 4]);
  81     let mut arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
  82     {
  83         let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
  84         gen_arr[2] = NoClone(10);
  85     }
  86     assert_eq!(arr, [NoClone(1), NoClone(2), NoClone(10), NoClone(4)]);
  87 }
  88
  89 #[test]
  90 fn test_default() {
  91     let arr = GenericArray::<u8, U1>::default();
  92     assert_eq!(arr[0], 0);
  93 }
  94
  95 #[test]
  96 fn test_from() {
  97     let data = [(1, 2, 3), (4, 5, 6), (7, 8, 9)];
  98     let garray: GenericArray<(usize, usize, usize), U3> = data.into();
  99     assert_eq!(&data, garray.as_slice());
 100 }
 101
 102 #[test]
 103 fn test_unit_macro() {
 104     let arr = arr![f32; 3.14];
 105     assert_eq!(arr[0], 3.14);
 106 }
 107
 108 #[test]
 109 fn test_empty_macro() {
 110     let _arr = arr![f32;];
 111 }
 112
 113 #[test]
 114 fn test_cmp() {
 115     arr![u8; 0x00].cmp(&arr![u8; 0x00]);
 116 }
 117
 118 /// This test should cause a helpful compile error if uncommented.
 119 // #[test]
 120 // fn test_empty_macro2(){
 121 //     let arr = arr![];
 122 // }
 123 #[cfg(feature = "serde")]
 124 mod impl_serde {
 125     extern crate serde_json;
 126
 127     use generic_array::GenericArray;
 128     use generic_array::typenum::U6;
 129
 130     #[test]
 131     fn test_serde_implementation() {
 132         let array: GenericArray<f64, U6> = arr![f64; 0.0, 5.0, 3.0, 7.07192, 76.0, -9.0];
 133         let string = serde_json::to_string(&array).unwrap();
 134         assert_eq!(string, "[0.0,5.0,3.0,7.07192,76.0,-9.0]");
 135
 136         let test_array: GenericArray<f64, U6> = serde_json::from_str(&string).unwrap();
 137         assert_eq!(test_array, array);
 138     }
 139 }
 140
 141 #[test]
 142 fn test_map() {
 143     let b: GenericArray<i32, U4> = GenericArray::generate(|i| i as i32 * 4).map(|x| x - 3);
 144
 145     assert_eq!(b, arr![i32; -3, 1, 5, 9]);
 146 }
 147
 148 #[test]
 149 fn test_zip() {
 150     let a: GenericArray<_, U4> = GenericArray::generate(|i| i + 1);
 151     let b: GenericArray<_, U4> = GenericArray::generate(|i| i as i32 * 4);
 152
 153     // Uses reference and non-reference arguments
 154     let c = (&a).zip(b, |r, l| *r as i32 + l);
 155
 156     assert_eq!(c, arr![i32; 1, 6, 11, 16]);
 157 }
 158
 159 #[test]
 160 #[should_panic]
 161 fn test_from_iter_short() {
 162     use core::iter::repeat;
 163
 164     let a: GenericArray<_, U4> = repeat(11).take(3).collect();
 165
 166     assert_eq!(a, arr![i32; 11, 11, 11, 0]);
 167 }
 168
 169 #[test]
 170 fn test_from_iter() {
 171     use core::iter::{once, repeat};
 172
 173     let a: GenericArray<_, U4> = repeat(11).take(3).chain(once(0)).collect();
 174
 175     assert_eq!(a, arr![i32; 11, 11, 11, 0]);
 176 }
 177
 178 #[test]
 179 fn test_sizes() {
 180     #![allow(dead_code)]
 181     use core::mem::{size_of, size_of_val};
 182
 183     #[derive(Debug, Copy, Clone)]
 184     #[repr(C)]
 185     #[repr(packed)]
 186     struct Test {
 187         t: u16,
 188         s: u32,
 189         r: u16,
 190         f: u16,
 191         o: u32,
 192     }
 193
 194     assert_eq!(size_of::<Test>(), 14);
 195
 196     assert_eq!(size_of_val(&arr![u8; 1, 2, 3]), size_of::<u8>() * 3);
 197     assert_eq!(size_of_val(&arr![u32; 1]), size_of::<u32>() * 1);
 198     assert_eq!(size_of_val(&arr![u64; 1, 2, 3, 4]), size_of::<u64>() * 4);
 199
 200     assert_eq!(size_of::<GenericArray<Test, U97>>(), size_of::<Test>() * 97);
 201 }
 202
 203 #[test]
 204 fn test_append() {
 205     let a = arr![i32; 1, 2, 3];
 206
 207     let b = a.append(4);
 208
 209     assert_eq!(b, arr![i32; 1, 2, 3, 4]);
 210 }
 211
 212 #[test]
 213 fn test_prepend() {
 214     let a = arr![i32; 1, 2, 3];
 215
 216     let b = a.prepend(4);
 217
 218     assert_eq!(b, arr![i32; 4, 1, 2, 3]);
 219 }
 220
 221 #[test]
 222 fn test_pop() {
 223     let a = arr![i32; 1, 2, 3, 4];
 224
 225     let (init, last) = a.pop_back();
 226
 227     assert_eq!(init, arr![i32; 1, 2, 3]);
 228     assert_eq!(last, 4);
 229
 230     let (head, tail) = a.pop_front();
 231
 232     assert_eq!(head, 1);
 233     assert_eq!(tail, arr![i32; 2, 3, 4]);
 234 }
 235
 236 #[test]
 237 fn test_split() {
 238     let a = arr![i32; 1, 2, 3, 4];
 239
 240     let (b, c) = a.split();
 241
 242     assert_eq!(b, arr![i32; 1]);
 243     assert_eq!(c, arr![i32; 2, 3, 4]);
 244
 245     let (e, f) = a.split();
 246
 247     assert_eq!(e, arr![i32; 1, 2]);
 248     assert_eq!(f, arr![i32; 3, 4]);
 249 }
 250
 251 #[test]
 252 fn test_concat() {
 253     let a = arr![i32; 1, 2];
 254     let b = arr![i32; 3, 4];
 255
 256     let c = a.concat(b);
 257
 258     assert_eq!(c, arr![i32; 1, 2, 3, 4]);
 259
 260     let (d, e) = c.split();
 261
 262     assert_eq!(d, arr![i32; 1]);
 263     assert_eq!(e, arr![i32; 2, 3, 4]);
 264 }
 265
 266 #[test]
 267 fn test_fold() {
 268     let a = arr![i32; 1, 2, 3, 4];
 269
 270     assert_eq!(10, a.fold(0, |a, x| a + x));
 271 }
 272
 273 fn sum_generic<S>(s: S) -> i32
 274 where
 275     S: FunctionalSequence<i32>,
 276     S::Item: Add<i32, Output = i32>, // `+`
 277     i32: Add<S::Item, Output = i32>, // reflexive
 278 {
 279     s.fold(0, |a, x| a + x)
 280 }
 281
 282 #[test]
 283 fn test_sum() {
 284     let a = sum_generic(arr![i32; 1, 2, 3, 4]);
 285
 286     assert_eq!(a, 10);
 287 }