libtest: rename `BenchHarness` to `Bencher`
Closes #12640
diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index 9d33ce6..c39914f 100644
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -940,7 +940,7 @@
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
                from_bytes};
@@ -1557,7 +1557,7 @@
     }
 
     #[bench]
-    fn bench_uint_small(b: &mut BenchHarness) {
+    fn bench_uint_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
@@ -1567,7 +1567,7 @@
     }
 
     #[bench]
-    fn bench_small_bitv_small(b: &mut BenchHarness) {
+    fn bench_small_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = SmallBitv::new(uint::BITS);
         b.iter(|| {
@@ -1577,7 +1577,7 @@
     }
 
     #[bench]
-    fn bench_big_bitv_small(b: &mut BenchHarness) {
+    fn bench_big_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BigBitv::new(vec!(0));
         b.iter(|| {
@@ -1587,7 +1587,7 @@
     }
 
     #[bench]
-    fn bench_big_bitv_big(b: &mut BenchHarness) {
+    fn bench_big_bitv_big(b: &mut Bencher) {
         let mut r = rng();
         let mut storage = vec!();
         storage.grow(BENCH_BITS / uint::BITS, &0u);
@@ -1599,7 +1599,7 @@
     }
 
     #[bench]
-    fn bench_bitv_big(b: &mut BenchHarness) {
+    fn bench_bitv_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
@@ -1609,7 +1609,7 @@
     }
 
     #[bench]
-    fn bench_bitv_small(b: &mut BenchHarness) {
+    fn bench_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::new(uint::BITS, false);
         b.iter(|| {
@@ -1619,7 +1619,7 @@
     }
 
     #[bench]
-    fn bench_bitv_set_small(b: &mut BenchHarness) {
+    fn bench_bitv_set_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -1629,7 +1629,7 @@
     }
 
     #[bench]
-    fn bench_bitv_set_big(b: &mut BenchHarness) {
+    fn bench_bitv_set_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -1639,7 +1639,7 @@
     }
 
     #[bench]
-    fn bench_bitv_big_union(b: &mut BenchHarness) {
+    fn bench_bitv_big_union(b: &mut Bencher) {
         let mut b1 = Bitv::new(BENCH_BITS, false);
         let b2 = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
@@ -1648,7 +1648,7 @@
     }
 
     #[bench]
-    fn bench_btv_small_iter(b: &mut BenchHarness) {
+    fn bench_btv_small_iter(b: &mut Bencher) {
         let bitv = Bitv::new(uint::BITS, false);
         b.iter(|| {
             let mut _sum = 0;
@@ -1659,7 +1659,7 @@
     }
 
     #[bench]
-    fn bench_bitv_big_iter(b: &mut BenchHarness) {
+    fn bench_bitv_big_iter(b: &mut Bencher) {
         let bitv = Bitv::new(BENCH_BITS, false);
         b.iter(|| {
             let mut _sum = 0;
@@ -1670,7 +1670,7 @@
     }
 
     #[bench]
-    fn bench_bitvset_iter(b: &mut BenchHarness) {
+    fn bench_bitvset_iter(b: &mut Bencher) {
         let bitv = BitvSet::from_bitv(from_fn(BENCH_BITS,
                                               |idx| {idx % 3 == 0}));
         b.iter(|| {
diff --git a/src/libcollections/deque.rs b/src/libcollections/deque.rs
index 24d3e2c..e031b07 100644
--- a/src/libcollections/deque.rs
+++ b/src/libcollections/deque.rs
@@ -42,14 +42,14 @@
 #[cfg(test)]
 pub mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use std::container::MutableMap;
     use rand;
     use rand::Rng;
 
     pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                   map: &mut M,
-                                                  bh: &mut BenchHarness) {
+                                                  b: &mut Bencher) {
         // setup
         let mut rng = rand::weak_rng();
 
@@ -59,7 +59,7 @@
         }
 
         // measure
-        bh.iter(|| {
+        b.iter(|| {
             let k = rng.gen::<uint>() % n;
             map.insert(k, 1);
             map.remove(&k);
@@ -68,7 +68,7 @@
 
     pub fn insert_seq_n<M:MutableMap<uint,uint>>(n: uint,
                                                  map: &mut M,
-                                                 bh: &mut BenchHarness) {
+                                                 b: &mut Bencher) {
         // setup
         map.clear();
         for i in range(0u, n) {
@@ -77,7 +77,7 @@
 
         // measure
         let mut i = 1;
-        bh.iter(|| {
+        b.iter(|| {
             map.insert(i, 1);
             map.remove(&i);
             i = (i + 2) % n;
@@ -86,7 +86,7 @@
 
     pub fn find_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                 map: &mut M,
-                                                bh: &mut BenchHarness) {
+                                                b: &mut Bencher) {
         // setup
         let mut rng = rand::weak_rng();
         let mut keys = Vec::from_fn(n, |_| rng.gen::<uint>() % n);
@@ -99,7 +99,7 @@
 
         // measure
         let mut i = 0;
-        bh.iter(|| {
+        b.iter(|| {
             map.find(keys.get(i));
             i = (i + 1) % n;
         })
@@ -107,7 +107,7 @@
 
     pub fn find_seq_n<M:MutableMap<uint,uint>>(n: uint,
                                                map: &mut M,
-                                               bh: &mut BenchHarness) {
+                                               b: &mut Bencher) {
         // setup
         for i in range(0u, n) {
             map.insert(i, 1);
@@ -115,7 +115,7 @@
 
         // measure
         let mut i = 0;
-        bh.iter(|| {
+        b.iter(|| {
             let x = map.find(&i);
             i = (i + 1) % n;
             x
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 3c1c7a3..eb5f216 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -631,7 +631,7 @@
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use deque::Deque;
     use rand;
     use super::{DList, Node, ListInsertion};
@@ -1082,7 +1082,7 @@
     }
 
     #[bench]
-    fn bench_collect_into(b: &mut test::BenchHarness) {
+    fn bench_collect_into(b: &mut test::Bencher) {
         let v = &[0, ..64];
         b.iter(|| {
             let _: DList<int> = v.iter().map(|x| *x).collect();
@@ -1090,7 +1090,7 @@
     }
 
     #[bench]
-    fn bench_push_front(b: &mut test::BenchHarness) {
+    fn bench_push_front(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         b.iter(|| {
             m.push_front(0);
@@ -1098,7 +1098,7 @@
     }
 
     #[bench]
-    fn bench_push_back(b: &mut test::BenchHarness) {
+    fn bench_push_back(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         b.iter(|| {
             m.push_back(0);
@@ -1106,7 +1106,7 @@
     }
 
     #[bench]
-    fn bench_push_back_pop_back(b: &mut test::BenchHarness) {
+    fn bench_push_back_pop_back(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         b.iter(|| {
             m.push_back(0);
@@ -1115,7 +1115,7 @@
     }
 
     #[bench]
-    fn bench_push_front_pop_front(b: &mut test::BenchHarness) {
+    fn bench_push_front_pop_front(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         b.iter(|| {
             m.push_front(0);
@@ -1124,7 +1124,7 @@
     }
 
     #[bench]
-    fn bench_rotate_forward(b: &mut test::BenchHarness) {
+    fn bench_rotate_forward(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         m.push_front(0);
         m.push_front(1);
@@ -1134,7 +1134,7 @@
     }
 
     #[bench]
-    fn bench_rotate_backward(b: &mut test::BenchHarness) {
+    fn bench_rotate_backward(b: &mut test::Bencher) {
         let mut m: DList<int> = DList::new();
         m.push_front(0);
         m.push_front(1);
@@ -1144,7 +1144,7 @@
     }
 
     #[bench]
-    fn bench_iter(b: &mut test::BenchHarness) {
+    fn bench_iter(b: &mut test::Bencher) {
         let v = &[0, ..128];
         let m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
@@ -1152,7 +1152,7 @@
         })
     }
     #[bench]
-    fn bench_iter_mut(b: &mut test::BenchHarness) {
+    fn bench_iter_mut(b: &mut test::Bencher) {
         let v = &[0, ..128];
         let mut m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
@@ -1160,7 +1160,7 @@
         })
     }
     #[bench]
-    fn bench_iter_rev(b: &mut test::BenchHarness) {
+    fn bench_iter_rev(b: &mut test::Bencher) {
         let v = &[0, ..128];
         let m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
@@ -1168,7 +1168,7 @@
         })
     }
     #[bench]
-    fn bench_iter_mut_rev(b: &mut test::BenchHarness) {
+    fn bench_iter_mut_rev(b: &mut test::Bencher) {
         let v = &[0, ..128];
         let mut m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs
index 9982a0c..a2413d7 100644
--- a/src/libcollections/hashmap.rs
+++ b/src/libcollections/hashmap.rs
@@ -2246,11 +2246,11 @@
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use std::iter::{range_inclusive};
 
     #[bench]
-    fn insert(b: &mut BenchHarness) {
+    fn insert(b: &mut Bencher) {
         use super::HashMap;
 
         let mut m = HashMap::new();
@@ -2268,7 +2268,7 @@
     }
 
     #[bench]
-    fn find_existing(b: &mut BenchHarness) {
+    fn find_existing(b: &mut Bencher) {
         use super::HashMap;
 
         let mut m = HashMap::new();
@@ -2283,7 +2283,7 @@
     }
 
     #[bench]
-    fn find_nonexisting(b: &mut BenchHarness) {
+    fn find_nonexisting(b: &mut Bencher) {
         use super::HashMap;
 
         let mut m = HashMap::new();
@@ -2298,7 +2298,7 @@
     }
 
     #[bench]
-    fn hashmap_as_queue(b: &mut BenchHarness) {
+    fn hashmap_as_queue(b: &mut Bencher) {
         use super::HashMap;
 
         let mut m = HashMap::new();
@@ -2317,7 +2317,7 @@
     }
 
     #[bench]
-    fn find_pop_insert(b: &mut BenchHarness) {
+    fn find_pop_insert(b: &mut Bencher) {
         use super::HashMap;
 
         let mut m = HashMap::new();
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index c61fcd0..19dc2d2 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -404,7 +404,7 @@
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use deque::Deque;
     use std::clone::Clone;
     use std::cmp::Eq;
@@ -546,14 +546,14 @@
     }
 
     #[bench]
-    fn bench_new(b: &mut test::BenchHarness) {
+    fn bench_new(b: &mut test::Bencher) {
         b.iter(|| {
             let _: RingBuf<u64> = RingBuf::new();
         })
     }
 
     #[bench]
-    fn bench_push_back(b: &mut test::BenchHarness) {
+    fn bench_push_back(b: &mut test::Bencher) {
         let mut deq = RingBuf::new();
         b.iter(|| {
             deq.push_back(0);
@@ -561,7 +561,7 @@
     }
 
     #[bench]
-    fn bench_push_front(b: &mut test::BenchHarness) {
+    fn bench_push_front(b: &mut test::Bencher) {
         let mut deq = RingBuf::new();
         b.iter(|| {
             deq.push_front(0);
@@ -569,7 +569,7 @@
     }
 
     #[bench]
-    fn bench_grow(b: &mut test::BenchHarness) {
+    fn bench_grow(b: &mut test::Bencher) {
         let mut deq = RingBuf::new();
         b.iter(|| {
             for _ in range(0, 65) {
diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index 4485987..6d7100a 100644
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -476,59 +476,59 @@
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use super::SmallIntMap;
     use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
 
     // Find seq
     #[bench]
-    pub fn insert_rand_100(bh: &mut BenchHarness) {
+    pub fn insert_rand_100(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        insert_rand_n(100, &mut m, bh);
+        insert_rand_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn insert_rand_10_000(bh: &mut BenchHarness) {
+    pub fn insert_rand_10_000(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        insert_rand_n(10_000, &mut m, bh);
+        insert_rand_n(10_000, &mut m, b);
     }
 
     // Insert seq
     #[bench]
-    pub fn insert_seq_100(bh: &mut BenchHarness) {
+    pub fn insert_seq_100(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        insert_seq_n(100, &mut m, bh);
+        insert_seq_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn insert_seq_10_000(bh: &mut BenchHarness) {
+    pub fn insert_seq_10_000(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        insert_seq_n(10_000, &mut m, bh);
+        insert_seq_n(10_000, &mut m, b);
     }
 
     // Find rand
     #[bench]
-    pub fn find_rand_100(bh: &mut BenchHarness) {
+    pub fn find_rand_100(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        find_rand_n(100, &mut m, bh);
+        find_rand_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn find_rand_10_000(bh: &mut BenchHarness) {
+    pub fn find_rand_10_000(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        find_rand_n(10_000, &mut m, bh);
+        find_rand_n(10_000, &mut m, b);
     }
 
     // Find seq
     #[bench]
-    pub fn find_seq_100(bh: &mut BenchHarness) {
+    pub fn find_seq_100(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        find_seq_n(100, &mut m, bh);
+        find_seq_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn find_seq_10_000(bh: &mut BenchHarness) {
+    pub fn find_seq_10_000(b: &mut Bencher) {
         let mut m : SmallIntMap<uint> = SmallIntMap::new();
-        find_seq_n(10_000, &mut m, bh);
+        find_seq_n(10_000, &mut m, b);
     }
 }
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index 1846ca0..d964e73 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -1428,60 +1428,60 @@
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use super::TreeMap;
     use deque::bench::{insert_rand_n, insert_seq_n, find_rand_n, find_seq_n};
 
     // Find seq
     #[bench]
-    pub fn insert_rand_100(bh: &mut BenchHarness) {
+    pub fn insert_rand_100(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        insert_rand_n(100, &mut m, bh);
+        insert_rand_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn insert_rand_10_000(bh: &mut BenchHarness) {
+    pub fn insert_rand_10_000(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        insert_rand_n(10_000, &mut m, bh);
+        insert_rand_n(10_000, &mut m, b);
     }
 
     // Insert seq
     #[bench]
-    pub fn insert_seq_100(bh: &mut BenchHarness) {
+    pub fn insert_seq_100(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        insert_seq_n(100, &mut m, bh);
+        insert_seq_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn insert_seq_10_000(bh: &mut BenchHarness) {
+    pub fn insert_seq_10_000(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        insert_seq_n(10_000, &mut m, bh);
+        insert_seq_n(10_000, &mut m, b);
     }
 
     // Find rand
     #[bench]
-    pub fn find_rand_100(bh: &mut BenchHarness) {
+    pub fn find_rand_100(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        find_rand_n(100, &mut m, bh);
+        find_rand_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn find_rand_10_000(bh: &mut BenchHarness) {
+    pub fn find_rand_10_000(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        find_rand_n(10_000, &mut m, bh);
+        find_rand_n(10_000, &mut m, b);
     }
 
     // Find seq
     #[bench]
-    pub fn find_seq_100(bh: &mut BenchHarness) {
+    pub fn find_seq_100(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        find_seq_n(100, &mut m, bh);
+        find_seq_n(100, &mut m, b);
     }
 
     #[bench]
-    pub fn find_seq_10_000(bh: &mut BenchHarness) {
+    pub fn find_seq_10_000(b: &mut Bencher) {
         let mut m : TreeMap<uint,uint> = TreeMap::new();
-        find_seq_n(10_000, &mut m, bh);
+        find_seq_n(10_000, &mut m, b);
     }
 }
 
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index 5c290d5..e831b39 100644
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -913,39 +913,39 @@
     extern crate test;
     use super::TrieMap;
     use rand::{weak_rng, Rng};
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     #[bench]
-    fn bench_iter_small(bh: &mut BenchHarness) {
+    fn bench_iter_small(b: &mut Bencher) {
         let mut m = TrieMap::<uint>::new();
         let mut rng = weak_rng();
         for _ in range(0, 20) {
             m.insert(rng.gen(), rng.gen());
         }
 
-        bh.iter(|| for _ in m.iter() {})
+        b.iter(|| for _ in m.iter() {})
     }
 
     #[bench]
-    fn bench_iter_large(bh: &mut BenchHarness) {
+    fn bench_iter_large(b: &mut Bencher) {
         let mut m = TrieMap::<uint>::new();
         let mut rng = weak_rng();
         for _ in range(0, 1000) {
             m.insert(rng.gen(), rng.gen());
         }
 
-        bh.iter(|| for _ in m.iter() {})
+        b.iter(|| for _ in m.iter() {})
     }
 
     #[bench]
-    fn bench_lower_bound(bh: &mut BenchHarness) {
+    fn bench_lower_bound(b: &mut Bencher) {
         let mut m = TrieMap::<uint>::new();
         let mut rng = weak_rng();
         for _ in range(0, 1000) {
             m.insert(rng.gen(), rng.gen());
         }
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 10) {
                     m.lower_bound(rng.gen());
                 }
@@ -953,14 +953,14 @@
     }
 
     #[bench]
-    fn bench_upper_bound(bh: &mut BenchHarness) {
+    fn bench_upper_bound(b: &mut Bencher) {
         let mut m = TrieMap::<uint>::new();
         let mut rng = weak_rng();
         for _ in range(0, 1000) {
             m.insert(rng.gen(), rng.gen());
         }
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 10) {
                     m.upper_bound(rng.gen());
                 }
@@ -968,22 +968,22 @@
     }
 
     #[bench]
-    fn bench_insert_large(bh: &mut BenchHarness) {
+    fn bench_insert_large(b: &mut Bencher) {
         let mut m = TrieMap::<[uint, .. 10]>::new();
         let mut rng = weak_rng();
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 1000) {
                     m.insert(rng.gen(), [1, .. 10]);
                 }
             })
     }
     #[bench]
-    fn bench_insert_large_low_bits(bh: &mut BenchHarness) {
+    fn bench_insert_large_low_bits(b: &mut Bencher) {
         let mut m = TrieMap::<[uint, .. 10]>::new();
         let mut rng = weak_rng();
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 1000) {
                     // only have the last few bits set.
                     m.insert(rng.gen::<uint>() & 0xff_ff, [1, .. 10]);
@@ -992,22 +992,22 @@
     }
 
     #[bench]
-    fn bench_insert_small(bh: &mut BenchHarness) {
+    fn bench_insert_small(b: &mut Bencher) {
         let mut m = TrieMap::<()>::new();
         let mut rng = weak_rng();
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 1000) {
                     m.insert(rng.gen(), ());
                 }
             })
     }
     #[bench]
-    fn bench_insert_small_low_bits(bh: &mut BenchHarness) {
+    fn bench_insert_small_low_bits(b: &mut Bencher) {
         let mut m = TrieMap::<()>::new();
         let mut rng = weak_rng();
 
-        bh.iter(|| {
+        b.iter(|| {
                 for _ in range(0, 1000) {
                     // only have the last few bits set.
                     m.insert(rng.gen::<uint>() & 0xff_ff, ());