vendor/crossbeam-utils/tests/cache_padded.rs

   1 extern crate crossbeam_utils;
   2
   3 use std::cell::Cell;
   4 use std::mem;
   5
   6 use crossbeam_utils::CachePadded;
   7
   8 #[test]
   9 fn default() {
  10     let x: CachePadded<u64> = Default::default();
  11     assert_eq!(*x, 0);
  12 }
  13
  14 #[test]
  15 fn store_u64() {
  16     let x: CachePadded<u64> = CachePadded::new(17);
  17     assert_eq!(*x, 17);
  18 }
  19
  20 #[test]
  21 fn store_pair() {
  22     let x: CachePadded<(u64, u64)> = CachePadded::new((17, 37));
  23     assert_eq!(x.0, 17);
  24     assert_eq!(x.1, 37);
  25 }
  26
  27 #[test]
  28 fn distance() {
  29     let arr = [CachePadded::new(17u8), CachePadded::new(37u8)];
  30     let a = &*arr[0] as *const u8;
  31     let b = &*arr[1] as *const u8;
  32     assert!(unsafe { a.offset(64) } <= b);
  33 }
  34
  35 #[test]
  36 fn different_sizes() {
  37     CachePadded::new(17u8);
  38     CachePadded::new(17u16);
  39     CachePadded::new(17u32);
  40     CachePadded::new([17u64; 0]);
  41     CachePadded::new([17u64; 1]);
  42     CachePadded::new([17u64; 2]);
  43     CachePadded::new([17u64; 3]);
  44     CachePadded::new([17u64; 4]);
  45     CachePadded::new([17u64; 5]);
  46     CachePadded::new([17u64; 6]);
  47     CachePadded::new([17u64; 7]);
  48     CachePadded::new([17u64; 8]);
  49 }
  50
  51 #[test]
  52 fn large() {
  53     let a = [17u64; 9];
  54     let b = CachePadded::new(a);
  55     assert!(mem::size_of_val(&a) <= mem::size_of_val(&b));
  56 }
  57
  58 #[test]
  59 fn debug() {
  60     assert_eq!(
  61         format!("{:?}", CachePadded::new(17u64)),
  62         "CachePadded { value: 17 }"
  63     );
  64 }
  65
  66 #[test]
  67 fn drops() {
  68     let count = Cell::new(0);
  69
  70     struct Foo<'a>(&'a Cell<usize>);
  71
  72     impl<'a> Drop for Foo<'a> {
  73         fn drop(&mut self) {
  74             self.0.set(self.0.get() + 1);
  75         }
  76     }
  77
  78     let a = CachePadded::new(Foo(&count));
  79     let b = CachePadded::new(Foo(&count));
  80
  81     assert_eq!(count.get(), 0);
  82     drop(a);
  83     assert_eq!(count.get(), 1);
  84     drop(b);
  85     assert_eq!(count.get(), 2);
  86 }
  87
  88 #[test]
  89 fn clone() {
  90     let a = CachePadded::new(17);
  91     let b = a.clone();
  92     assert_eq!(*a, *b);
  93 }
  94
  95 #[test]
  96 fn runs_custom_clone() {
  97     let count = Cell::new(0);
  98
  99     struct Foo<'a>(&'a Cell<usize>);
 100
 101     impl<'a> Clone for Foo<'a> {
 102         fn clone(&self) -> Foo<'a> {
 103             self.0.set(self.0.get() + 1);
 104             Foo::<'a>(self.0)
 105         }
 106     }
 107
 108     let a = CachePadded::new(Foo(&count));
 109     let _ = a.clone();
 110
 111     assert_eq!(count.get(), 1);
 112 }