libtest: rename `BenchHarness` to `Bencher`

Closes #12640

16 files changed, 265 insertions, 265 deletions

diff --git a/src/libstd/any.rs b/src/libstd/any.rs
index 80ead34b68a..e204e082f4b 100644
--- a/src/libstd/any.rs
+++ b/src/libstd/any.rs
@@ -306,11 +306,11 @@ mod bench {
 
     use any::{Any, AnyRefExt};
     use option::Some;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     #[bench]
-    fn bench_as_ref(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn bench_as_ref(b: &mut Bencher) {
+        b.iter(|| {
             let mut x = 0; let mut y = &mut x as &mut Any;
             test::black_box(&mut y);
             test::black_box(y.as_ref::<int>() == Some(&0));
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index 6acf0eb0cee..a7234eeb1d5 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -670,7 +670,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use libc;
     use prelude::*;
 
@@ -696,73 +696,73 @@ mod bench {
         Mary had a little lamb, Little lamb
         Mary had a little lamb, Little lamb";
 
-    fn bench_to_str(bh: &mut BenchHarness, s: &str) {
-        bh.iter(|| {
+    fn bench_to_str(b: &mut Bencher, s: &str) {
+        b.iter(|| {
             let c_str = s.to_c_str();
             c_str.with_ref(|c_str_buf| check(s, c_str_buf))
         })
     }
 
     #[bench]
-    fn bench_to_c_str_short(bh: &mut BenchHarness) {
-        bench_to_str(bh, s_short)
+    fn bench_to_c_str_short(b: &mut Bencher) {
+        bench_to_str(b, s_short)
     }
 
     #[bench]
-    fn bench_to_c_str_medium(bh: &mut BenchHarness) {
-        bench_to_str(bh, s_medium)
+    fn bench_to_c_str_medium(b: &mut Bencher) {
+        bench_to_str(b, s_medium)
     }
 
     #[bench]
-    fn bench_to_c_str_long(bh: &mut BenchHarness) {
-        bench_to_str(bh, s_long)
+    fn bench_to_c_str_long(b: &mut Bencher) {
+        bench_to_str(b, s_long)
     }
 
-    fn bench_to_c_str_unchecked(bh: &mut BenchHarness, s: &str) {
-        bh.iter(|| {
+    fn bench_to_c_str_unchecked(b: &mut Bencher, s: &str) {
+        b.iter(|| {
             let c_str = unsafe { s.to_c_str_unchecked() };
             c_str.with_ref(|c_str_buf| check(s, c_str_buf))
         })
     }
 
     #[bench]
-    fn bench_to_c_str_unchecked_short(bh: &mut BenchHarness) {
-        bench_to_c_str_unchecked(bh, s_short)
+    fn bench_to_c_str_unchecked_short(b: &mut Bencher) {
+        bench_to_c_str_unchecked(b, s_short)
     }
 
     #[bench]
-    fn bench_to_c_str_unchecked_medium(bh: &mut BenchHarness) {
-        bench_to_c_str_unchecked(bh, s_medium)
+    fn bench_to_c_str_unchecked_medium(b: &mut Bencher) {
+        bench_to_c_str_unchecked(b, s_medium)
     }
 
     #[bench]
-    fn bench_to_c_str_unchecked_long(bh: &mut BenchHarness) {
-        bench_to_c_str_unchecked(bh, s_long)
+    fn bench_to_c_str_unchecked_long(b: &mut Bencher) {
+        bench_to_c_str_unchecked(b, s_long)
     }
 
-    fn bench_with_c_str(bh: &mut BenchHarness, s: &str) {
-        bh.iter(|| {
+    fn bench_with_c_str(b: &mut Bencher, s: &str) {
+        b.iter(|| {
             s.with_c_str(|c_str_buf| check(s, c_str_buf))
         })
     }
 
     #[bench]
-    fn bench_with_c_str_short(bh: &mut BenchHarness) {
-        bench_with_c_str(bh, s_short)
+    fn bench_with_c_str_short(b: &mut Bencher) {
+        bench_with_c_str(b, s_short)
     }
 
     #[bench]
-    fn bench_with_c_str_medium(bh: &mut BenchHarness) {
-        bench_with_c_str(bh, s_medium)
+    fn bench_with_c_str_medium(b: &mut Bencher) {
+        bench_with_c_str(b, s_medium)
     }
 
     #[bench]
-    fn bench_with_c_str_long(bh: &mut BenchHarness) {
-        bench_with_c_str(bh, s_long)
+    fn bench_with_c_str_long(b: &mut Bencher) {
+        bench_with_c_str(b, s_long)
     }
 
-    fn bench_with_c_str_unchecked(bh: &mut BenchHarness, s: &str) {
-        bh.iter(|| {
+    fn bench_with_c_str_unchecked(b: &mut Bencher, s: &str) {
+        b.iter(|| {
             unsafe {
                 s.with_c_str_unchecked(|c_str_buf| check(s, c_str_buf))
             }
@@ -770,17 +770,17 @@ mod bench {
     }
 
     #[bench]
-    fn bench_with_c_str_unchecked_short(bh: &mut BenchHarness) {
-        bench_with_c_str_unchecked(bh, s_short)
+    fn bench_with_c_str_unchecked_short(b: &mut Bencher) {
+        bench_with_c_str_unchecked(b, s_short)
     }
 
     #[bench]
-    fn bench_with_c_str_unchecked_medium(bh: &mut BenchHarness) {
-        bench_with_c_str_unchecked(bh, s_medium)
+    fn bench_with_c_str_unchecked_medium(b: &mut Bencher) {
+        bench_with_c_str_unchecked(b, s_medium)
     }
 
     #[bench]
-    fn bench_with_c_str_unchecked_long(bh: &mut BenchHarness) {
-        bench_with_c_str_unchecked(bh, s_long)
+    fn bench_with_c_str_unchecked_long(b: &mut Bencher) {
+        bench_with_c_str_unchecked(b, s_long)
     }
 }
diff --git a/src/libstd/fmt/num.rs b/src/libstd/fmt/num.rs
index 4d1d08551a6..88b21f1f87b 100644
--- a/src/libstd/fmt/num.rs
+++ b/src/libstd/fmt/num.rs
@@ -394,74 +394,74 @@ mod bench {
     extern crate test;
 
     mod uint {
-        use super::test::BenchHarness;
+        use super::test::Bencher;
         use fmt::radix;
         use rand::{XorShiftRng, Rng};
 
         #[bench]
-        fn format_bin(bh: &mut BenchHarness) {
+        fn format_bin(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:t}", rng.gen::<uint>()); })
+            b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
         }
 
         #[bench]
-        fn format_oct(bh: &mut BenchHarness) {
+        fn format_oct(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:o}", rng.gen::<uint>()); })
+            b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
         }
 
         #[bench]
-        fn format_dec(bh: &mut BenchHarness) {
+        fn format_dec(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:u}", rng.gen::<uint>()); })
+            b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
         }
 
         #[bench]
-        fn format_hex(bh: &mut BenchHarness) {
+        fn format_hex(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:x}", rng.gen::<uint>()); })
+            b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
         }
 
         #[bench]
-        fn format_base_36(bh: &mut BenchHarness) {
+        fn format_base_36(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
+            b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
         }
     }
 
     mod int {
-        use super::test::BenchHarness;
+        use super::test::Bencher;
         use fmt::radix;
         use rand::{XorShiftRng, Rng};
 
         #[bench]
-        fn format_bin(bh: &mut BenchHarness) {
+        fn format_bin(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:t}", rng.gen::<int>()); })
+            b.iter(|| { format!("{:t}", rng.gen::<int>()); })
         }
 
         #[bench]
-        fn format_oct(bh: &mut BenchHarness) {
+        fn format_oct(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:o}", rng.gen::<int>()); })
+            b.iter(|| { format!("{:o}", rng.gen::<int>()); })
         }
 
         #[bench]
-        fn format_dec(bh: &mut BenchHarness) {
+        fn format_dec(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:d}", rng.gen::<int>()); })
+            b.iter(|| { format!("{:d}", rng.gen::<int>()); })
         }
 
         #[bench]
-        fn format_hex(bh: &mut BenchHarness) {
+        fn format_hex(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{:x}", rng.gen::<int>()); })
+            b.iter(|| { format!("{:x}", rng.gen::<int>()); })
         }
 
         #[bench]
-        fn format_base_36(bh: &mut BenchHarness) {
+        fn format_base_36(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
+            b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
         }
     }
 }
diff --git a/src/libstd/hash/sip.rs b/src/libstd/hash/sip.rs
index 4a523e3d09e..63844fcd414 100644
--- a/src/libstd/hash/sip.rs
+++ b/src/libstd/hash/sip.rs
@@ -294,7 +294,7 @@ mod tests {
     use str::Str;
     use strbuf::StrBuf;
     use slice::{Vector, ImmutableVector, OwnedVector};
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     use super::super::Hash;
     use super::{SipState, hash, hash_with_keys};
@@ -517,9 +517,9 @@ mod tests {
     }
 
     #[bench]
-    fn bench_str(bh: &mut BenchHarness) {
+    fn bench_str(b: &mut Bencher) {
         let s = "foo";
-        bh.iter(|| {
+        b.iter(|| {
             assert_eq!(hash(&s), 16262950014981195938);
         })
     }
@@ -540,13 +540,13 @@ mod tests {
     }
 
     #[bench]
-    fn bench_compound_1(bh: &mut BenchHarness) {
+    fn bench_compound_1(b: &mut Bencher) {
         let compound = Compound {
             x: 1,
             y: 2,
             z: ~"foobarbaz",
         };
-        bh.iter(|| {
+        b.iter(|| {
             assert_eq!(hash(&compound), 3581836382593270478);
         })
     }
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index c9d412973ec..8fe7f0ca595 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -371,7 +371,7 @@ mod test {
     use prelude::*;
     use super::*;
     use super::super::mem::{MemReader, MemWriter, BufReader};
-    use Harness = self::test::BenchHarness;
+    use self::test::Bencher;
 
     /// A type, free to create, primarily intended for benchmarking creation of
     /// wrappers that, just for construction, don't need a Reader/Writer that
@@ -584,22 +584,22 @@ mod test {
     }
 
     #[bench]
-    fn bench_buffered_reader(bh: &mut Harness) {
-        bh.iter(|| {
+    fn bench_buffered_reader(b: &mut Bencher) {
+        b.iter(|| {
             BufferedReader::new(NullStream)
         });
     }
 
     #[bench]
-    fn bench_buffered_writer(bh: &mut Harness) {
-        bh.iter(|| {
+    fn bench_buffered_writer(b: &mut Bencher) {
+        b.iter(|| {
             BufferedWriter::new(NullStream)
         });
     }
 
     #[bench]
-    fn bench_buffered_stream(bh: &mut Harness) {
-        bh.iter(|| {
+    fn bench_buffered_stream(b: &mut Bencher) {
+        b.iter(|| {
             BufferedStream::new(NullStream);
         });
     }
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index e1eaa2792bf..b2202a13057 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -503,7 +503,7 @@ mod test {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use container::Container;
 
     macro_rules! u64_from_be_bytes_bench_impl(
@@ -514,7 +514,7 @@ mod bench {
 
             let data = slice::from_fn($stride*100+$start_index, |i| i as u8);
             let mut sum = 0u64;
-            bh.iter(|| {
+            b.iter(|| {
                 let mut i = $start_index;
                 while i < data.len() {
                     sum += u64_from_be_bytes(data, i, $size);
@@ -525,32 +525,32 @@ mod bench {
     )
 
     #[bench]
-    fn u64_from_be_bytes_4_aligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_4_aligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(4, 4, 0);
     }
 
     #[bench]
-    fn u64_from_be_bytes_4_unaligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_4_unaligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(4, 4, 1);
     }
 
     #[bench]
-    fn u64_from_be_bytes_7_aligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_7_aligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(7, 8, 0);
     }
 
     #[bench]
-    fn u64_from_be_bytes_7_unaligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_7_unaligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(7, 8, 1);
     }
 
     #[bench]
-    fn u64_from_be_bytes_8_aligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_8_aligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(8, 8, 0);
     }
 
     #[bench]
-    fn u64_from_be_bytes_8_unaligned(bh: &mut BenchHarness) {
+    fn u64_from_be_bytes_8_unaligned(b: &mut Bencher) {
         u64_from_be_bytes_bench_impl!(8, 8, 1);
     }
 }
diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
index 0e709445770..deefb3fe2ed 100644
--- a/src/libstd/mem.rs
+++ b/src/libstd/mem.rs
@@ -363,7 +363,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use option::{Some,None};
 
     // Static/dynamic method dispatch
@@ -383,18 +383,18 @@ mod bench {
     }
 
     #[bench]
-    fn trait_vtable_method_call(bh: &mut BenchHarness) {
+    fn trait_vtable_method_call(b: &mut Bencher) {
         let s = Struct { field: 10 };
         let t = &s as &Trait;
-        bh.iter(|| {
+        b.iter(|| {
             t.method()
         });
     }
 
     #[bench]
-    fn trait_static_method_call(bh: &mut BenchHarness) {
+    fn trait_static_method_call(b: &mut Bencher) {
         let s = Struct { field: 10 };
-        bh.iter(|| {
+        b.iter(|| {
             s.method()
         });
     }
@@ -402,9 +402,9 @@ mod bench {
     // Overhead of various match forms
 
     #[bench]
-    fn match_option_some(bh: &mut BenchHarness) {
+    fn match_option_some(b: &mut Bencher) {
         let x = Some(10);
-        bh.iter(|| {
+        b.iter(|| {
             match x {
                 Some(y) => y,
                 None => 11
@@ -413,9 +413,9 @@ mod bench {
     }
 
     #[bench]
-    fn match_vec_pattern(bh: &mut BenchHarness) {
+    fn match_vec_pattern(b: &mut Bencher) {
         let x = [1,2,3,4,5,6];
-        bh.iter(|| {
+        b.iter(|| {
             match x {
                 [1,2,3,..] => 10,
                 _ => 11
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 9d0b53f945f..52167fa58b9 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -1773,13 +1773,13 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use num;
     use slice;
     use prelude::*;
 
     #[bench]
-    fn bench_pow_function(b: &mut BenchHarness) {
+    fn bench_pow_function(b: &mut Bencher) {
         let v = slice::from_fn(1024, |n| n);
         b.iter(|| {v.iter().fold(0, |old, new| num::pow(old, *new));});
     }
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b15b5872fc2..3ce9a3d0764 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -815,86 +815,86 @@ mod bench {
     extern crate test;
 
     mod uint {
-        use super::test::BenchHarness;
+        use super::test::Bencher;
         use rand::{XorShiftRng, Rng};
         use num::ToStrRadix;
 
         #[bench]
-        fn to_str_bin(bh: &mut BenchHarness) {
+        fn to_str_bin(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<uint>().to_str_radix(2); })
+            b.iter(|| { rng.gen::<uint>().to_str_radix(2); })
         }
 
         #[bench]
-        fn to_str_oct(bh: &mut BenchHarness) {
+        fn to_str_oct(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<uint>().to_str_radix(8); })
+            b.iter(|| { rng.gen::<uint>().to_str_radix(8); })
         }
 
         #[bench]
-        fn to_str_dec(bh: &mut BenchHarness) {
+        fn to_str_dec(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<uint>().to_str_radix(10); })
+            b.iter(|| { rng.gen::<uint>().to_str_radix(10); })
         }
 
         #[bench]
-        fn to_str_hex(bh: &mut BenchHarness) {
+        fn to_str_hex(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<uint>().to_str_radix(16); })
+            b.iter(|| { rng.gen::<uint>().to_str_radix(16); })
         }
 
         #[bench]
-        fn to_str_base_36(bh: &mut BenchHarness) {
+        fn to_str_base_36(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<uint>().to_str_radix(36); })
+            b.iter(|| { rng.gen::<uint>().to_str_radix(36); })
         }
     }
 
     mod int {
-        use super::test::BenchHarness;
+        use super::test::Bencher;
         use rand::{XorShiftRng, Rng};
         use num::ToStrRadix;
 
         #[bench]
-        fn to_str_bin(bh: &mut BenchHarness) {
+        fn to_str_bin(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<int>().to_str_radix(2); })
+            b.iter(|| { rng.gen::<int>().to_str_radix(2); })
         }
 
         #[bench]
-        fn to_str_oct(bh: &mut BenchHarness) {
+        fn to_str_oct(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<int>().to_str_radix(8); })
+            b.iter(|| { rng.gen::<int>().to_str_radix(8); })
         }
 
         #[bench]
-        fn to_str_dec(bh: &mut BenchHarness) {
+        fn to_str_dec(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<int>().to_str_radix(10); })
+            b.iter(|| { rng.gen::<int>().to_str_radix(10); })
         }
 
         #[bench]
-        fn to_str_hex(bh: &mut BenchHarness) {
+        fn to_str_hex(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<int>().to_str_radix(16); })
+            b.iter(|| { rng.gen::<int>().to_str_radix(16); })
         }
 
         #[bench]
-        fn to_str_base_36(bh: &mut BenchHarness) {
+        fn to_str_base_36(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { rng.gen::<int>().to_str_radix(36); })
+            b.iter(|| { rng.gen::<int>().to_str_radix(36); })
         }
     }
 
     mod f64 {
-        use super::test::BenchHarness;
+        use super::test::Bencher;
         use rand::{XorShiftRng, Rng};
         use f64;
 
         #[bench]
-        fn float_to_str(bh: &mut BenchHarness) {
+        fn float_to_str(b: &mut Bencher) {
             let mut rng = XorShiftRng::new().unwrap();
-            bh.iter(|| { f64::to_str(rng.gen()); })
+            b.iter(|| { f64::to_str(rng.gen()); })
         }
     }
 }
diff --git a/src/libstd/ops.rs b/src/libstd/ops.rs
index 75928e2921e..4c31face2e3 100644
--- a/src/libstd/ops.rs
+++ b/src/libstd/ops.rs
@@ -551,7 +551,7 @@ pub trait DerefMut<Result>: Deref<Result> {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use ops::Drop;
 
     // Overhead of dtors
@@ -566,8 +566,8 @@ mod bench {
     }
 
     #[bench]
-    fn alloc_obj_with_dtor(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn alloc_obj_with_dtor(b: &mut Bencher) {
+        b.iter(|| {
             HasDtor { x : 10 };
         })
     }
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 098b3edb69d..69504a2ec8f 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -1253,127 +1253,127 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use super::*;
     use prelude::*;
 
     #[bench]
-    fn join_home_dir(bh: &mut BenchHarness) {
+    fn join_home_dir(b: &mut Bencher) {
         let posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.join("home");
         });
     }
 
     #[bench]
-    fn join_abs_path_home_dir(bh: &mut BenchHarness) {
+    fn join_abs_path_home_dir(b: &mut Bencher) {
         let posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.join("/home");
         });
     }
 
     #[bench]
-    fn join_many_home_dir(bh: &mut BenchHarness) {
+    fn join_many_home_dir(b: &mut Bencher) {
         let posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.join_many(&["home"]);
         });
     }
 
     #[bench]
-    fn join_many_abs_path_home_dir(bh: &mut BenchHarness) {
+    fn join_many_abs_path_home_dir(b: &mut Bencher) {
         let posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.join_many(&["/home"]);
         });
     }
 
     #[bench]
-    fn push_home_dir(bh: &mut BenchHarness) {
+    fn push_home_dir(b: &mut Bencher) {
         let mut posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.push("home");
         });
     }
 
     #[bench]
-    fn push_abs_path_home_dir(bh: &mut BenchHarness) {
+    fn push_abs_path_home_dir(b: &mut Bencher) {
         let mut posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.push("/home");
         });
     }
 
     #[bench]
-    fn push_many_home_dir(bh: &mut BenchHarness) {
+    fn push_many_home_dir(b: &mut Bencher) {
         let mut posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.push_many(&["home"]);
         });
     }
 
     #[bench]
-    fn push_many_abs_path_home_dir(bh: &mut BenchHarness) {
+    fn push_many_abs_path_home_dir(b: &mut Bencher) {
         let mut posix_path = Path::new("/");
-        bh.iter(|| {
+        b.iter(|| {
             posix_path.push_many(&["/home"]);
         });
     }
 
     #[bench]
-    fn ends_with_path_home_dir(bh: &mut BenchHarness) {
+    fn ends_with_path_home_dir(b: &mut Bencher) {
         let posix_home_path = Path::new("/home");
-        bh.iter(|| {
+        b.iter(|| {
             posix_home_path.ends_with_path(&Path::new("home"));
         });
     }
 
     #[bench]
-    fn ends_with_path_missmatch_jome_home(bh: &mut BenchHarness) {
+    fn ends_with_path_missmatch_jome_home(b: &mut Bencher) {
         let posix_home_path = Path::new("/home");
-        bh.iter(|| {
+        b.iter(|| {
             posix_home_path.ends_with_path(&Path::new("jome"));
         });
     }
 
     #[bench]
-    fn is_ancestor_of_path_with_10_dirs(bh: &mut BenchHarness) {
+    fn is_ancestor_of_path_with_10_dirs(b: &mut Bencher) {
         let path = Path::new("/home/1/2/3/4/5/6/7/8/9");
         let mut sub = path.clone();
         sub.pop();
-        bh.iter(|| {
+        b.iter(|| {
             path.is_ancestor_of(&sub);
         });
     }
 
     #[bench]
-    fn path_relative_from_forward(bh: &mut BenchHarness) {
+    fn path_relative_from_forward(b: &mut Bencher) {
         let path = Path::new("/a/b/c");
         let mut other = path.clone();
         other.pop();
-        bh.iter(|| {
+        b.iter(|| {
             path.path_relative_from(&other);
         });
     }
 
     #[bench]
-    fn path_relative_from_same_level(bh: &mut BenchHarness) {
+    fn path_relative_from_same_level(b: &mut Bencher) {
         let path = Path::new("/a/b/c");
         let mut other = path.clone();
         other.pop();
         other.push("d");
-        bh.iter(|| {
+        b.iter(|| {
             path.path_relative_from(&other);
         });
     }
 
     #[bench]
-    fn path_relative_from_backward(bh: &mut BenchHarness) {
+    fn path_relative_from_backward(b: &mut Bencher) {
         let path = Path::new("/a/b");
         let mut other = path.clone();
         other.push("c");
-        bh.iter(|| {
+        b.iter(|| {
             path.path_relative_from(&other);
         });
     }
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index 5c1b6cd4791..01949a7057b 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -117,18 +117,18 @@ pub unsafe fn exchange_free(ptr: *u8) {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     #[bench]
-    fn alloc_owned_small(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn alloc_owned_small(b: &mut Bencher) {
+        b.iter(|| {
             ~10
         })
     }
 
     #[bench]
-    fn alloc_owned_big(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn alloc_owned_big(b: &mut Bencher) {
+        b.iter(|| {
             ~[10, ..1000]
         })
     }
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index 163e69f9686..b9d0d829374 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -326,15 +326,15 @@ pub fn live_allocs() -> *mut Box {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
 
     #[bench]
-    fn alloc_managed_small(bh: &mut BenchHarness) {
-        bh.iter(|| { @10; });
+    fn alloc_managed_small(b: &mut Bencher) {
+        b.iter(|| { @10; });
     }
 
     #[bench]
-    fn alloc_managed_big(bh: &mut BenchHarness) {
-        bh.iter(|| { @([10, ..1000]); });
+    fn alloc_managed_big(b: &mut Bencher) {
+        b.iter(|| { @([10, ..1000]); });
     }
 }
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index fced9b5dd5b..28c5b56a7a7 100644
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -4273,7 +4273,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use mem;
     use prelude::*;
     use ptr;
@@ -4281,12 +4281,12 @@ mod bench {
     use slice;
 
     #[bench]
-    fn iterator(bh: &mut BenchHarness) {
+    fn iterator(b: &mut Bencher) {
         // peculiar numbers to stop LLVM from optimising the summation
         // out.
         let v = slice::from_fn(100, |i| i ^ (i << 1) ^ (i >> 1));
 
-        bh.iter(|| {
+        b.iter(|| {
             let mut sum = 0;
             for x in v.iter() {
                 sum += *x;
@@ -4297,10 +4297,10 @@ mod bench {
     }
 
     #[bench]
-    fn mut_iterator(bh: &mut BenchHarness) {
+    fn mut_iterator(b: &mut Bencher) {
         let mut v = slice::from_elem(100, 0);
 
-        bh.iter(|| {
+        b.iter(|| {
             let mut i = 0;
             for x in v.mut_iter() {
                 *x = i;
@@ -4310,109 +4310,109 @@ mod bench {
     }
 
     #[bench]
-    fn add(bh: &mut BenchHarness) {
+    fn add(b: &mut Bencher) {
         let xs: &[int] = [5, ..10];
         let ys: &[int] = [5, ..10];
-        bh.iter(|| {
+        b.iter(|| {
             xs + ys;
         });
     }
 
     #[bench]
-    fn concat(bh: &mut BenchHarness) {
+    fn concat(b: &mut Bencher) {
         let xss: &[~[uint]] = slice::from_fn(100, |i| range(0, i).collect());
-        bh.iter(|| {
+        b.iter(|| {
             let _ = xss.concat_vec();
         });
     }
 
     #[bench]
-    fn connect(bh: &mut BenchHarness) {
+    fn connect(b: &mut Bencher) {
         let xss: &[~[uint]] = slice::from_fn(100, |i| range(0, i).collect());
-        bh.iter(|| {
+        b.iter(|| {
             let _ = xss.connect_vec(&0);
         });
     }
 
     #[bench]
-    fn push(bh: &mut BenchHarness) {
+    fn push(b: &mut Bencher) {
         let mut vec: ~[uint] = ~[0u];
-        bh.iter(|| {
+        b.iter(|| {
             vec.push(0);
             &vec
         })
     }
 
     #[bench]
-    fn starts_with_same_vector(bh: &mut BenchHarness) {
+    fn starts_with_same_vector(b: &mut Bencher) {
         let vec: ~[uint] = slice::from_fn(100, |i| i);
-        bh.iter(|| {
+        b.iter(|| {
             vec.starts_with(vec)
         })
     }
 
     #[bench]
-    fn starts_with_single_element(bh: &mut BenchHarness) {
+    fn starts_with_single_element(b: &mut Bencher) {
         let vec: ~[uint] = ~[0u];
-        bh.iter(|| {
+        b.iter(|| {
             vec.starts_with(vec)
         })
     }
 
     #[bench]
-    fn starts_with_diff_one_element_at_end(bh: &mut BenchHarness) {
+    fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
         let vec: ~[uint] = slice::from_fn(100, |i| i);
         let mut match_vec: ~[uint] = slice::from_fn(99, |i| i);
         match_vec.push(0);
-        bh.iter(|| {
+        b.iter(|| {
             vec.starts_with(match_vec)
         })
     }
 
     #[bench]
-    fn ends_with_same_vector(bh: &mut BenchHarness) {
+    fn ends_with_same_vector(b: &mut Bencher) {
         let vec: ~[uint] = slice::from_fn(100, |i| i);
-        bh.iter(|| {
+        b.iter(|| {
             vec.ends_with(vec)
         })
     }
 
     #[bench]
-    fn ends_with_single_element(bh: &mut BenchHarness) {
+    fn ends_with_single_element(b: &mut Bencher) {
         let vec: ~[uint] = ~[0u];
-        bh.iter(|| {
+        b.iter(|| {
             vec.ends_with(vec)
         })
     }
 
     #[bench]
-    fn ends_with_diff_one_element_at_beginning(bh: &mut BenchHarness) {
+    fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
         let vec: ~[uint] = slice::from_fn(100, |i| i);
         let mut match_vec: ~[uint] = slice::from_fn(100, |i| i);
         match_vec[0] = 200;
-        bh.iter(|| {
+        b.iter(|| {
             vec.starts_with(match_vec)
         })
     }
 
     #[bench]
-    fn contains_last_element(bh: &mut BenchHarness) {
+    fn contains_last_element(b: &mut Bencher) {
         let vec: ~[uint] = slice::from_fn(100, |i| i);
-        bh.iter(|| {
+        b.iter(|| {
             vec.contains(&99u)
         })
     }
 
     #[bench]
-    fn zero_1kb_from_elem(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn zero_1kb_from_elem(b: &mut Bencher) {
+        b.iter(|| {
             let _v: ~[u8] = slice::from_elem(1024, 0u8);
         });
     }
 
     #[bench]
-    fn zero_1kb_set_memory(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn zero_1kb_set_memory(b: &mut Bencher) {
+        b.iter(|| {
             let mut v: ~[u8] = slice::with_capacity(1024);
             unsafe {
                 let vp = v.as_mut_ptr();
@@ -4424,17 +4424,17 @@ mod bench {
     }
 
     #[bench]
-    fn zero_1kb_fixed_repeat(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn zero_1kb_fixed_repeat(b: &mut Bencher) {
+        b.iter(|| {
             ~[0u8, ..1024]
         });
     }
 
     #[bench]
-    fn zero_1kb_loop_set(bh: &mut BenchHarness) {
+    fn zero_1kb_loop_set(b: &mut Bencher) {
         // Slower because the { len, cap, [0 x T] }* repr allows a pointer to the length
         // field to be aliased (in theory) and prevents LLVM from optimizing loads away.
-        bh.iter(|| {
+        b.iter(|| {
             let mut v: ~[u8] = slice::with_capacity(1024);
             unsafe {
                 v.set_len(1024);
@@ -4446,8 +4446,8 @@ mod bench {
     }
 
     #[bench]
-    fn zero_1kb_mut_iter(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn zero_1kb_mut_iter(b: &mut Bencher) {
+        b.iter(|| {
             let mut v: ~[u8] = slice::with_capacity(1024);
             unsafe {
                 v.set_len(1024);
@@ -4460,9 +4460,9 @@ mod bench {
     }
 
     #[bench]
-    fn random_inserts(bh: &mut BenchHarness) {
+    fn random_inserts(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
                 let mut v = slice::from_elem(30, (0u, 0u));
                 for _ in range(0, 100) {
                     let l = v.len();
@@ -4472,9 +4472,9 @@ mod bench {
             })
     }
     #[bench]
-    fn random_removes(bh: &mut BenchHarness) {
+    fn random_removes(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
                 let mut v = slice::from_elem(130, (0u, 0u));
                 for _ in range(0, 100) {
                     let l = v.len();
@@ -4484,82 +4484,82 @@ mod bench {
     }
 
     #[bench]
-    fn sort_random_small(bh: &mut BenchHarness) {
+    fn sort_random_small(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<u64>(5);
             v.as_mut_slice().sort();
         });
-        bh.bytes = 5 * mem::size_of::<u64>() as u64;
+        b.bytes = 5 * mem::size_of::<u64>() as u64;
     }
 
     #[bench]
-    fn sort_random_medium(bh: &mut BenchHarness) {
+    fn sort_random_medium(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<u64>(100);
             v.as_mut_slice().sort();
         });
-        bh.bytes = 100 * mem::size_of::<u64>() as u64;
+        b.bytes = 100 * mem::size_of::<u64>() as u64;
     }
 
     #[bench]
-    fn sort_random_large(bh: &mut BenchHarness) {
+    fn sort_random_large(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<u64>(10000);
             v.as_mut_slice().sort();
         });
-        bh.bytes = 10000 * mem::size_of::<u64>() as u64;
+        b.bytes = 10000 * mem::size_of::<u64>() as u64;
     }
 
     #[bench]
-    fn sort_sorted(bh: &mut BenchHarness) {
+    fn sort_sorted(b: &mut Bencher) {
         let mut v = slice::from_fn(10000, |i| i);
-        bh.iter(|| {
+        b.iter(|| {
             v.sort();
         });
-        bh.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 
     type BigSortable = (u64,u64,u64,u64);
 
     #[bench]
-    fn sort_big_random_small(bh: &mut BenchHarness) {
+    fn sort_big_random_small(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<BigSortable>(5);
             v.sort();
         });
-        bh.bytes = 5 * mem::size_of::<BigSortable>() as u64;
+        b.bytes = 5 * mem::size_of::<BigSortable>() as u64;
     }
 
     #[bench]
-    fn sort_big_random_medium(bh: &mut BenchHarness) {
+    fn sort_big_random_medium(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<BigSortable>(100);
             v.sort();
         });
-        bh.bytes = 100 * mem::size_of::<BigSortable>() as u64;
+        b.bytes = 100 * mem::size_of::<BigSortable>() as u64;
     }
 
     #[bench]
-    fn sort_big_random_large(bh: &mut BenchHarness) {
+    fn sort_big_random_large(b: &mut Bencher) {
         let mut rng = weak_rng();
-        bh.iter(|| {
+        b.iter(|| {
             let mut v = rng.gen_vec::<BigSortable>(10000);
             v.sort();
         });
-        bh.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
+        b.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
     }
 
     #[bench]
-    fn sort_big_sorted(bh: &mut BenchHarness) {
+    fn sort_big_sorted(b: &mut Bencher) {
         let mut v = slice::from_fn(10000u, |i| (i, i, i, i));
-        bh.iter(|| {
+        b.iter(|| {
             v.sort();
         });
-        bh.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 }
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 525988c698f..904c19b40ed 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -4099,20 +4099,20 @@ mod tests {
 #[cfg(test)]
 mod bench {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use super::*;
     use prelude::*;
 
     #[bench]
-    fn char_iterator(bh: &mut BenchHarness) {
+    fn char_iterator(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let len = s.char_len();
 
-        bh.iter(|| assert_eq!(s.chars().len(), len));
+        b.iter(|| assert_eq!(s.chars().len(), len));
     }
 
     #[bench]
-    fn char_iterator_ascii(bh: &mut BenchHarness) {
+    fn char_iterator_ascii(b: &mut Bencher) {
         let s = "Mary had a little lamb, Little lamb
         Mary had a little lamb, Little lamb
         Mary had a little lamb, Little lamb
@@ -4121,42 +4121,42 @@ mod bench {
         Mary had a little lamb, Little lamb";
         let len = s.char_len();
 
-        bh.iter(|| assert_eq!(s.chars().len(), len));
+        b.iter(|| assert_eq!(s.chars().len(), len));
     }
 
     #[bench]
-    fn char_iterator_rev(bh: &mut BenchHarness) {
+    fn char_iterator_rev(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let len = s.char_len();
 
-        bh.iter(|| assert_eq!(s.chars_rev().len(), len));
+        b.iter(|| assert_eq!(s.chars_rev().len(), len));
     }
 
     #[bench]
-    fn char_indicesator(bh: &mut BenchHarness) {
+    fn char_indicesator(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let len = s.char_len();
 
-        bh.iter(|| assert_eq!(s.char_indices().len(), len));
+        b.iter(|| assert_eq!(s.char_indices().len(), len));
     }
 
     #[bench]
-    fn char_indicesator_rev(bh: &mut BenchHarness) {
+    fn char_indicesator_rev(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let len = s.char_len();
 
-        bh.iter(|| assert_eq!(s.char_indices_rev().len(), len));
+        b.iter(|| assert_eq!(s.char_indices_rev().len(), len));
     }
 
     #[bench]
-    fn split_unicode_ascii(bh: &mut BenchHarness) {
+    fn split_unicode_ascii(b: &mut Bencher) {
         let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
 
-        bh.iter(|| assert_eq!(s.split('V').len(), 3));
+        b.iter(|| assert_eq!(s.split('V').len(), 3));
     }
 
     #[bench]
-    fn split_unicode_not_ascii(bh: &mut BenchHarness) {
+    fn split_unicode_not_ascii(b: &mut Bencher) {
         struct NotAscii(char);
         impl CharEq for NotAscii {
             fn matches(&self, c: char) -> bool {
@@ -4167,20 +4167,20 @@ mod bench {
         }
         let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
 
-        bh.iter(|| assert_eq!(s.split(NotAscii('V')).len(), 3));
+        b.iter(|| assert_eq!(s.split(NotAscii('V')).len(), 3));
     }
 
 
     #[bench]
-    fn split_ascii(bh: &mut BenchHarness) {
+    fn split_ascii(b: &mut Bencher) {
         let s = "Mary had a little lamb, Little lamb, little-lamb.";
         let len = s.split(' ').len();
 
-        bh.iter(|| assert_eq!(s.split(' ').len(), len));
+        b.iter(|| assert_eq!(s.split(' ').len(), len));
     }
 
     #[bench]
-    fn split_not_ascii(bh: &mut BenchHarness) {
+    fn split_not_ascii(b: &mut Bencher) {
         struct NotAscii(char);
         impl CharEq for NotAscii {
             #[inline]
@@ -4193,97 +4193,97 @@ mod bench {
         let s = "Mary had a little lamb, Little lamb, little-lamb.";
         let len = s.split(' ').len();
 
-        bh.iter(|| assert_eq!(s.split(NotAscii(' ')).len(), len));
+        b.iter(|| assert_eq!(s.split(NotAscii(' ')).len(), len));
     }
 
     #[bench]
-    fn split_extern_fn(bh: &mut BenchHarness) {
+    fn split_extern_fn(b: &mut Bencher) {
         let s = "Mary had a little lamb, Little lamb, little-lamb.";
         let len = s.split(' ').len();
         fn pred(c: char) -> bool { c == ' ' }
 
-        bh.iter(|| assert_eq!(s.split(pred).len(), len));
+        b.iter(|| assert_eq!(s.split(pred).len(), len));
     }
 
     #[bench]
-    fn split_closure(bh: &mut BenchHarness) {
+    fn split_closure(b: &mut Bencher) {
         let s = "Mary had a little lamb, Little lamb, little-lamb.";
         let len = s.split(' ').len();
 
-        bh.iter(|| assert_eq!(s.split(|c: char| c == ' ').len(), len));
+        b.iter(|| assert_eq!(s.split(|c: char| c == ' ').len(), len));
     }
 
     #[bench]
-    fn split_slice(bh: &mut BenchHarness) {
+    fn split_slice(b: &mut Bencher) {
         let s = "Mary had a little lamb, Little lamb, little-lamb.";
         let len = s.split(' ').len();
 
-        bh.iter(|| assert_eq!(s.split(&[' ']).len(), len));
+        b.iter(|| assert_eq!(s.split(&[' ']).len(), len));
     }
 
     #[bench]
-    fn is_utf8_100_ascii(bh: &mut BenchHarness) {
+    fn is_utf8_100_ascii(b: &mut Bencher) {
 
         let s = bytes!("Hello there, the quick brown fox jumped over the lazy dog! \
                         Lorem ipsum dolor sit amet, consectetur. ");
 
         assert_eq!(100, s.len());
-        bh.iter(|| {
+        b.iter(|| {
             is_utf8(s)
         });
     }
 
     #[bench]
-    fn is_utf8_100_multibyte(bh: &mut BenchHarness) {
+    fn is_utf8_100_multibyte(b: &mut Bencher) {
         let s = bytes!("𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰");
         assert_eq!(100, s.len());
-        bh.iter(|| {
+        b.iter(|| {
             is_utf8(s)
         });
     }
 
     #[bench]
-    fn from_utf8_lossy_100_ascii(bh: &mut BenchHarness) {
+    fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
         let s = bytes!("Hello there, the quick brown fox jumped over the lazy dog! \
                         Lorem ipsum dolor sit amet, consectetur. ");
 
         assert_eq!(100, s.len());
-        bh.iter(|| {
+        b.iter(|| {
             let _ = from_utf8_lossy(s);
         });
     }
 
     #[bench]
-    fn from_utf8_lossy_100_multibyte(bh: &mut BenchHarness) {
+    fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
         let s = bytes!("𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰");
         assert_eq!(100, s.len());
-        bh.iter(|| {
+        b.iter(|| {
             let _ = from_utf8_lossy(s);
         });
     }
 
     #[bench]
-    fn from_utf8_lossy_invalid(bh: &mut BenchHarness) {
+    fn from_utf8_lossy_invalid(b: &mut Bencher) {
         let s = bytes!("Hello", 0xC0, 0x80, " There", 0xE6, 0x83, " Goodbye");
-        bh.iter(|| {
+        b.iter(|| {
             let _ = from_utf8_lossy(s);
         });
     }
 
     #[bench]
-    fn from_utf8_lossy_100_invalid(bh: &mut BenchHarness) {
+    fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
         let s = ::slice::from_elem(100, 0xF5u8);
-        bh.iter(|| {
+        b.iter(|| {
             let _ = from_utf8_lossy(s);
         });
     }
 
     #[bench]
-    fn bench_connect(bh: &mut BenchHarness) {
+    fn bench_connect(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let sep = "→";
         let v = [s, s, s, s, s, s, s, s, s, s];
-        bh.iter(|| {
+        b.iter(|| {
             assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
         })
     }
diff --git a/src/libstd/strbuf.rs b/src/libstd/strbuf.rs
index 1fcc9c6465a..c2add625a77 100644
--- a/src/libstd/strbuf.rs
+++ b/src/libstd/strbuf.rs
@@ -289,21 +289,21 @@ impl<H:Writer> ::hash::Hash<H> for StrBuf {
 #[cfg(test)]
 mod tests {
     extern crate test;
-    use self::test::BenchHarness;
+    use self::test::Bencher;
     use str::{Str, StrSlice};
     use super::StrBuf;
 
     #[bench]
-    fn bench_with_capacity(bh: &mut BenchHarness) {
-        bh.iter(|| {
+    fn bench_with_capacity(b: &mut Bencher) {
+        b.iter(|| {
             StrBuf::with_capacity(100)
         });
     }
 
     #[bench]
-    fn bench_push_str(bh: &mut BenchHarness) {
+    fn bench_push_str(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-        bh.iter(|| {
+        b.iter(|| {
             let mut r = StrBuf::new();
             r.push_str(s);
         });