compiler/rustc_data_structures/src/tiny_list/tests.rs

   1 use super::*;
   2
   3 extern crate test;
   4 use test::{black_box, Bencher};
   5
   6 impl<T> TinyList<T> {
   7     fn len(&self) -> usize {
   8         let (mut elem, mut count) = (self.head.as_ref(), 0);
   9         while let Some(ref e) = elem {
  10             count += 1;
  11             elem = e.next.as_deref();
  12         }
  13         count
  14     }
  15 }
  16
  17 #[test]
  18 fn test_contains_and_insert() {
  19     fn do_insert(i: u32) -> bool {
  20         i % 2 == 0
  21     }
  22
  23     let mut list = TinyList::new();
  24
  25     for i in 0..10 {
  26         for j in 0..i {
  27             if do_insert(j) {
  28                 assert!(list.contains(&j));
  29             } else {
  30                 assert!(!list.contains(&j));
  31             }
  32         }
  33
  34         assert!(!list.contains(&i));
  35
  36         if do_insert(i) {
  37             list.insert(i);
  38             assert!(list.contains(&i));
  39         }
  40     }
  41 }
  42
  43 #[test]
  44 fn test_remove_first() {
  45     let mut list = TinyList::new();
  46     list.insert(1);
  47     list.insert(2);
  48     list.insert(3);
  49     list.insert(4);
  50     assert_eq!(list.len(), 4);
  51
  52     assert!(list.remove(&4));
  53     assert!(!list.contains(&4));
  54
  55     assert_eq!(list.len(), 3);
  56     assert!(list.contains(&1));
  57     assert!(list.contains(&2));
  58     assert!(list.contains(&3));
  59 }
  60
  61 #[test]
  62 fn test_remove_last() {
  63     let mut list = TinyList::new();
  64     list.insert(1);
  65     list.insert(2);
  66     list.insert(3);
  67     list.insert(4);
  68     assert_eq!(list.len(), 4);
  69
  70     assert!(list.remove(&1));
  71     assert!(!list.contains(&1));
  72
  73     assert_eq!(list.len(), 3);
  74     assert!(list.contains(&2));
  75     assert!(list.contains(&3));
  76     assert!(list.contains(&4));
  77 }
  78
  79 #[test]
  80 fn test_remove_middle() {
  81     let mut list = TinyList::new();
  82     list.insert(1);
  83     list.insert(2);
  84     list.insert(3);
  85     list.insert(4);
  86     assert_eq!(list.len(), 4);
  87
  88     assert!(list.remove(&2));
  89     assert!(!list.contains(&2));
  90
  91     assert_eq!(list.len(), 3);
  92     assert!(list.contains(&1));
  93     assert!(list.contains(&3));
  94     assert!(list.contains(&4));
  95 }
  96
  97 #[test]
  98 fn test_remove_single() {
  99     let mut list = TinyList::new();
 100     list.insert(1);
 101     assert_eq!(list.len(), 1);
 102
 103     assert!(list.remove(&1));
 104     assert!(!list.contains(&1));
 105
 106     assert_eq!(list.len(), 0);
 107 }
 108
 109 #[bench]
 110 fn bench_insert_empty(b: &mut Bencher) {
 111     b.iter(|| {
 112         let mut list = black_box(TinyList::new());
 113         list.insert(1);
 114         list
 115     })
 116 }
 117
 118 #[bench]
 119 fn bench_insert_one(b: &mut Bencher) {
 120     b.iter(|| {
 121         let mut list = black_box(TinyList::new_single(0));
 122         list.insert(1);
 123         list
 124     })
 125 }
 126
 127 #[bench]
 128 fn bench_contains_empty(b: &mut Bencher) {
 129     b.iter(|| black_box(TinyList::new()).contains(&1));
 130 }
 131
 132 #[bench]
 133 fn bench_contains_unknown(b: &mut Bencher) {
 134     b.iter(|| black_box(TinyList::new_single(0)).contains(&1));
 135 }
 136
 137 #[bench]
 138 fn bench_contains_one(b: &mut Bencher) {
 139     b.iter(|| black_box(TinyList::new_single(1)).contains(&1));
 140 }
 141
 142 #[bench]
 143 fn bench_remove_empty(b: &mut Bencher) {
 144     b.iter(|| black_box(TinyList::new()).remove(&1));
 145 }
 146
 147 #[bench]
 148 fn bench_remove_unknown(b: &mut Bencher) {
 149     b.iter(|| black_box(TinyList::new_single(0)).remove(&1));
 150 }
 151
 152 #[bench]
 153 fn bench_remove_one(b: &mut Bencher) {
 154     b.iter(|| black_box(TinyList::new_single(1)).remove(&1));
 155 }