src/librustc_data_structures/tiny_list/tests.rs

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