Merge remote-tracking branch 'rust-lang/master'

Conflicts:
	mk/tests.mk
	src/liballoc/arc.rs
	src/liballoc/boxed.rs
	src/liballoc/rc.rs
	src/libcollections/bit.rs
	src/libcollections/btree/map.rs
	src/libcollections/btree/set.rs
	src/libcollections/dlist.rs
	src/libcollections/ring_buf.rs
	src/libcollections/slice.rs
	src/libcollections/str.rs
	src/libcollections/string.rs
	src/libcollections/vec.rs
	src/libcollections/vec_map.rs
	src/libcore/any.rs
	src/libcore/array.rs
	src/libcore/borrow.rs
	src/libcore/error.rs
	src/libcore/fmt/mod.rs
	src/libcore/iter.rs
	src/libcore/marker.rs
	src/libcore/ops.rs
	src/libcore/result.rs
	src/libcore/slice.rs
	src/libcore/str/mod.rs
	src/libregex/lib.rs
	src/libregex/re.rs
	src/librustc/lint/builtin.rs
	src/libstd/collections/hash/map.rs
	src/libstd/collections/hash/set.rs
	src/libstd/sync/mpsc/mod.rs
	src/libstd/sync/mutex.rs
	src/libstd/sync/poison.rs
	src/libstd/sync/rwlock.rs
	src/libsyntax/feature_gate.rs
	src/libsyntax/test.rs

7 files changed, 148 insertions, 91 deletions

diff --git a/src/libcoretest/finally.rs b/src/libcoretest/finally.rs
index 979ddaecb4a..6ec87203e00 100644
--- a/src/libcoretest/finally.rs
+++ b/src/libcoretest/finally.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(deprecated)]
+
 use core::finally::{try_finally, Finally};
 use std::thread::Thread;
 
diff --git a/src/libcoretest/fmt/mod.rs b/src/libcoretest/fmt/mod.rs
index 3f2208e6c2d..e7792014446 100644
--- a/src/libcoretest/fmt/mod.rs
+++ b/src/libcoretest/fmt/mod.rs
@@ -14,5 +14,5 @@ mod num;
 fn test_format_flags() {
     // No residual flags left by pointer formatting
     let p = "".as_ptr();
-    assert_eq!(format!("{:p} {:x}", p, 16u), format!("{:p} 10", p));
+    assert_eq!(format!("{:p} {:x}", p, 16), format!("{:p} 10", p));
 }
diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs
index c259e4cbb68..17180076cd8 100644
--- a/src/libcoretest/fmt/num.rs
+++ b/src/libcoretest/fmt/num.rs
@@ -16,115 +16,115 @@ fn test_format_int() {
     // Formatting integers should select the right implementation based off
     // the type of the argument. Also, hex/octal/binary should be defined
     // for integers, but they shouldn't emit the negative sign.
-    assert!(format!("{}", 1i) == "1");
+    assert!(format!("{}", 1is) == "1");
     assert!(format!("{}", 1i8) == "1");
     assert!(format!("{}", 1i16) == "1");
     assert!(format!("{}", 1i32) == "1");
     assert!(format!("{}", 1i64) == "1");
-    assert!(format!("{}", -1i) == "-1");
+    assert!(format!("{}", -1is) == "-1");
     assert!(format!("{}", -1i8) == "-1");
     assert!(format!("{}", -1i16) == "-1");
     assert!(format!("{}", -1i32) == "-1");
     assert!(format!("{}", -1i64) == "-1");
-    assert!(format!("{:?}", 1i) == "1i");
-    assert!(format!("{:?}", 1i8) == "1i8");
-    assert!(format!("{:?}", 1i16) == "1i16");
-    assert!(format!("{:?}", 1i32) == "1i32");
-    assert!(format!("{:?}", 1i64) == "1i64");
-    assert!(format!("{:b}", 1i) == "1");
+    assert!(format!("{:?}", 1is) == "1");
+    assert!(format!("{:?}", 1i8) == "1");
+    assert!(format!("{:?}", 1i16) == "1");
+    assert!(format!("{:?}", 1i32) == "1");
+    assert!(format!("{:?}", 1i64) == "1");
+    assert!(format!("{:b}", 1is) == "1");
     assert!(format!("{:b}", 1i8) == "1");
     assert!(format!("{:b}", 1i16) == "1");
     assert!(format!("{:b}", 1i32) == "1");
     assert!(format!("{:b}", 1i64) == "1");
-    assert!(format!("{:x}", 1i) == "1");
+    assert!(format!("{:x}", 1is) == "1");
     assert!(format!("{:x}", 1i8) == "1");
     assert!(format!("{:x}", 1i16) == "1");
     assert!(format!("{:x}", 1i32) == "1");
     assert!(format!("{:x}", 1i64) == "1");
-    assert!(format!("{:X}", 1i) == "1");
+    assert!(format!("{:X}", 1is) == "1");
     assert!(format!("{:X}", 1i8) == "1");
     assert!(format!("{:X}", 1i16) == "1");
     assert!(format!("{:X}", 1i32) == "1");
     assert!(format!("{:X}", 1i64) == "1");
-    assert!(format!("{:o}", 1i) == "1");
+    assert!(format!("{:o}", 1is) == "1");
     assert!(format!("{:o}", 1i8) == "1");
     assert!(format!("{:o}", 1i16) == "1");
     assert!(format!("{:o}", 1i32) == "1");
     assert!(format!("{:o}", 1i64) == "1");
 
-    assert!(format!("{}", 1u) == "1");
+    assert!(format!("{}", 1us) == "1");
     assert!(format!("{}", 1u8) == "1");
     assert!(format!("{}", 1u16) == "1");
     assert!(format!("{}", 1u32) == "1");
     assert!(format!("{}", 1u64) == "1");
-    assert!(format!("{:?}", 1u) == "1u");
-    assert!(format!("{:?}", 1u8) == "1u8");
-    assert!(format!("{:?}", 1u16) == "1u16");
-    assert!(format!("{:?}", 1u32) == "1u32");
-    assert!(format!("{:?}", 1u64) == "1u64");
-    assert!(format!("{:b}", 1u) == "1");
+    assert!(format!("{:?}", 1us) == "1");
+    assert!(format!("{:?}", 1u8) == "1");
+    assert!(format!("{:?}", 1u16) == "1");
+    assert!(format!("{:?}", 1u32) == "1");
+    assert!(format!("{:?}", 1u64) == "1");
+    assert!(format!("{:b}", 1us) == "1");
     assert!(format!("{:b}", 1u8) == "1");
     assert!(format!("{:b}", 1u16) == "1");
     assert!(format!("{:b}", 1u32) == "1");
     assert!(format!("{:b}", 1u64) == "1");
-    assert!(format!("{:x}", 1u) == "1");
+    assert!(format!("{:x}", 1us) == "1");
     assert!(format!("{:x}", 1u8) == "1");
     assert!(format!("{:x}", 1u16) == "1");
     assert!(format!("{:x}", 1u32) == "1");
     assert!(format!("{:x}", 1u64) == "1");
-    assert!(format!("{:X}", 1u) == "1");
+    assert!(format!("{:X}", 1us) == "1");
     assert!(format!("{:X}", 1u8) == "1");
     assert!(format!("{:X}", 1u16) == "1");
     assert!(format!("{:X}", 1u32) == "1");
     assert!(format!("{:X}", 1u64) == "1");
-    assert!(format!("{:o}", 1u) == "1");
+    assert!(format!("{:o}", 1us) == "1");
     assert!(format!("{:o}", 1u8) == "1");
     assert!(format!("{:o}", 1u16) == "1");
     assert!(format!("{:o}", 1u32) == "1");
     assert!(format!("{:o}", 1u64) == "1");
 
     // Test a larger number
-    assert!(format!("{:b}", 55i) == "110111");
-    assert!(format!("{:o}", 55i) == "67");
-    assert!(format!("{}", 55i) == "55");
-    assert!(format!("{:x}", 55i) == "37");
-    assert!(format!("{:X}", 55i) == "37");
+    assert!(format!("{:b}", 55) == "110111");
+    assert!(format!("{:o}", 55) == "67");
+    assert!(format!("{}", 55) == "55");
+    assert!(format!("{:x}", 55) == "37");
+    assert!(format!("{:X}", 55) == "37");
 }
 
 #[test]
 fn test_format_int_zero() {
-    assert!(format!("{}", 0i) == "0");
-    assert!(format!("{:?}", 0i) == "0i");
-    assert!(format!("{:b}", 0i) == "0");
-    assert!(format!("{:o}", 0i) == "0");
-    assert!(format!("{:x}", 0i) == "0");
-    assert!(format!("{:X}", 0i) == "0");
-
-    assert!(format!("{}", 0u) == "0");
-    assert!(format!("{:?}", 0u) == "0u");
-    assert!(format!("{:b}", 0u) == "0");
-    assert!(format!("{:o}", 0u) == "0");
-    assert!(format!("{:x}", 0u) == "0");
-    assert!(format!("{:X}", 0u) == "0");
+    assert!(format!("{}", 0) == "0");
+    assert!(format!("{:?}", 0) == "0");
+    assert!(format!("{:b}", 0) == "0");
+    assert!(format!("{:o}", 0) == "0");
+    assert!(format!("{:x}", 0) == "0");
+    assert!(format!("{:X}", 0) == "0");
+
+    assert!(format!("{}", 0u32) == "0");
+    assert!(format!("{:?}", 0u32) == "0");
+    assert!(format!("{:b}", 0u32) == "0");
+    assert!(format!("{:o}", 0u32) == "0");
+    assert!(format!("{:x}", 0u32) == "0");
+    assert!(format!("{:X}", 0u32) == "0");
 }
 
 #[test]
 fn test_format_int_flags() {
-    assert!(format!("{:3}", 1i) == "  1");
-    assert!(format!("{:>3}", 1i) == "  1");
-    assert!(format!("{:>+3}", 1i) == " +1");
-    assert!(format!("{:<3}", 1i) == "1  ");
-    assert!(format!("{:#}", 1i) == "1");
-    assert!(format!("{:#x}", 10i) == "0xa");
-    assert!(format!("{:#X}", 10i) == "0xA");
-    assert!(format!("{:#5x}", 10i) == "  0xa");
-    assert!(format!("{:#o}", 10i) == "0o12");
-    assert!(format!("{:08x}", 10i) == "0000000a");
-    assert!(format!("{:8x}", 10i) == "       a");
-    assert!(format!("{:<8x}", 10i) == "a       ");
-    assert!(format!("{:>8x}", 10i) == "       a");
-    assert!(format!("{:#08x}", 10i) == "0x00000a");
-    assert!(format!("{:08}", -10i) == "-0000010");
+    assert!(format!("{:3}", 1) == "  1");
+    assert!(format!("{:>3}", 1) == "  1");
+    assert!(format!("{:>+3}", 1) == " +1");
+    assert!(format!("{:<3}", 1) == "1  ");
+    assert!(format!("{:#}", 1) == "1");
+    assert!(format!("{:#x}", 10) == "0xa");
+    assert!(format!("{:#X}", 10) == "0xA");
+    assert!(format!("{:#5x}", 10) == "  0xa");
+    assert!(format!("{:#o}", 10) == "0o12");
+    assert!(format!("{:08x}", 10) == "0000000a");
+    assert!(format!("{:8x}", 10) == "       a");
+    assert!(format!("{:<8x}", 10) == "a       ");
+    assert!(format!("{:>8x}", 10) == "       a");
+    assert!(format!("{:#08x}", 10) == "0x00000a");
+    assert!(format!("{:08}", -10) == "-0000010");
     assert!(format!("{:x}", -1u8) == "ff");
     assert!(format!("{:X}", -1u8) == "FF");
     assert!(format!("{:b}", -1u8) == "11111111");
@@ -137,12 +137,12 @@ fn test_format_int_flags() {
 
 #[test]
 fn test_format_int_sign_padding() {
-    assert!(format!("{:+5}", 1i) == "   +1");
-    assert!(format!("{:+5}", -1i) == "   -1");
-    assert!(format!("{:05}", 1i) == "00001");
-    assert!(format!("{:05}", -1i) == "-0001");
-    assert!(format!("{:+05}", 1i) == "+0001");
-    assert!(format!("{:+05}", -1i) == "-0001");
+    assert!(format!("{:+5}", 1) == "   +1");
+    assert!(format!("{:+5}", -1) == "   -1");
+    assert!(format!("{:05}", 1) == "00001");
+    assert!(format!("{:05}", -1) == "-0001");
+    assert!(format!("{:+05}", 1) == "+0001");
+    assert!(format!("{:+05}", -1) == "-0001");
 }
 
 #[test]
@@ -156,96 +156,98 @@ fn test_format_int_twos_complement() {
 
 #[test]
 fn test_format_radix() {
-    assert!(format!("{:04}", radix(3i, 2)) == "0011");
-    assert!(format!("{}", radix(55i, 36)) == "1j");
+    assert!(format!("{:04}", radix(3, 2)) == "0011");
+    assert!(format!("{}", radix(55, 36)) == "1j");
 }
 
 #[test]
 #[should_fail]
 fn test_radix_base_too_large() {
-    let _ = radix(55i, 37);
+    let _ = radix(55, 37);
 }
 
-mod uint {
+mod u32 {
     use test::Bencher;
     use core::fmt::radix;
     use std::rand::{weak_rng, Rng};
+    use std::io::util::NullWriter;
 
     #[bench]
     fn format_bin(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:b}", rng.gen::<uint>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:b}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_oct(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:o}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_dec(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{}", rng.gen::<uint>()); })
+        b.iter(|| { write!(&mut NullWriter, "{}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_hex(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:x}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_show(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:?}", rng.gen::<uint>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:?}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_base_36(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
+        b.iter(|| { write!(&mut NullWriter, "{}", radix(rng.gen::<u32>(), 36)) })
     }
 }
 
-mod int {
+mod i32 {
     use test::Bencher;
     use core::fmt::radix;
     use std::rand::{weak_rng, Rng};
+    use std::io::util::NullWriter;
 
     #[bench]
     fn format_bin(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:b}", rng.gen::<int>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:b}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_oct(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:o}", rng.gen::<int>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:o}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_dec(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{}", rng.gen::<int>()); })
+        b.iter(|| { write!(&mut NullWriter, "{}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_hex(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:x}", rng.gen::<int>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:x}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_show(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{:?}", rng.gen::<int>()); })
+        b.iter(|| { write!(&mut NullWriter, "{:?}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_base_36(b: &mut Bencher) {
         let mut rng = weak_rng();
-        b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
+        b.iter(|| { write!(&mut NullWriter, "{}", radix(rng.gen::<i32>(), 36)) })
     }
 }
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 26819bf9209..9481245f120 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -120,18 +120,32 @@ fn test_iterator_enumerate() {
 fn test_iterator_peekable() {
     let xs = vec![0u, 1, 2, 3, 4, 5];
     let mut it = xs.iter().map(|&x|x).peekable();
+
+    assert_eq!(it.len(), 6);
     assert_eq!(it.peek().unwrap(), &0);
+    assert_eq!(it.len(), 6);
     assert_eq!(it.next().unwrap(), 0);
+    assert_eq!(it.len(), 5);
     assert_eq!(it.next().unwrap(), 1);
+    assert_eq!(it.len(), 4);
     assert_eq!(it.next().unwrap(), 2);
+    assert_eq!(it.len(), 3);
     assert_eq!(it.peek().unwrap(), &3);
+    assert_eq!(it.len(), 3);
     assert_eq!(it.peek().unwrap(), &3);
+    assert_eq!(it.len(), 3);
     assert_eq!(it.next().unwrap(), 3);
+    assert_eq!(it.len(), 2);
     assert_eq!(it.next().unwrap(), 4);
+    assert_eq!(it.len(), 1);
     assert_eq!(it.peek().unwrap(), &5);
+    assert_eq!(it.len(), 1);
     assert_eq!(it.next().unwrap(), 5);
+    assert_eq!(it.len(), 0);
     assert!(it.peek().is_none());
+    assert_eq!(it.len(), 0);
     assert!(it.next().is_none());
+    assert_eq!(it.len(), 0);
 }
 
 #[test]
@@ -166,24 +180,45 @@ fn test_iterator_skip() {
     let ys = [13, 15, 16, 17, 19, 20, 30];
     let mut it = xs.iter().skip(5);
     let mut i = 0;
-    for &x in it {
+    while let Some(&x) = it.next() {
         assert_eq!(x, ys[i]);
         i += 1;
+        assert_eq!(it.len(), xs.len()-5-i);
     }
     assert_eq!(i, ys.len());
+    assert_eq!(it.len(), 0);
 }
 
 #[test]
 fn test_iterator_take() {
-    let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
-    let ys = [0u, 1, 2, 3, 5];
+    let xs = [0us, 1, 2, 3, 5, 13, 15, 16, 17, 19];
+    let ys = [0us, 1, 2, 3, 5];
     let mut it = xs.iter().take(5);
     let mut i = 0;
-    for &x in it {
+    assert_eq!(it.len(), 5);
+    while let Some(&x) = it.next() {
+        assert_eq!(x, ys[i]);
+        i += 1;
+        assert_eq!(it.len(), 5-i);
+    }
+    assert_eq!(i, ys.len());
+    assert_eq!(it.len(), 0);
+}
+
+#[test]
+fn test_iterator_take_short() {
+    let xs = [0us, 1, 2, 3];
+    let ys = [0us, 1, 2, 3];
+    let mut it = xs.iter().take(5);
+    let mut i = 0;
+    assert_eq!(it.len(), 4);
+    while let Some(&x) = it.next() {
         assert_eq!(x, ys[i]);
         i += 1;
+        assert_eq!(it.len(), 4-i);
     }
     assert_eq!(i, ys.len());
+    assert_eq!(it.len(), 0);
 }
 
 #[test]
@@ -585,7 +620,7 @@ fn check_randacc_iter<A, T>(a: T, len: uint) where
 fn test_double_ended_flat_map() {
     let u = [0u,1];
     let v = [5u,6,7,8];
-    let mut it = u.iter().flat_map(|x| v[(*x)..v.len()].iter());
+    let mut it = u.iter().flat_map(|x| v[*x..v.len()].iter());
     assert_eq!(it.next_back().unwrap(), &8);
     assert_eq!(it.next().unwrap(),      &5);
     assert_eq!(it.next_back().unwrap(), &7);
@@ -828,6 +863,24 @@ fn test_repeat() {
     assert_eq!(it.next(), Some(42u));
 }
 
+#[test]
+fn test_fuse() {
+    let mut it = 0us..3;
+    assert_eq!(it.len(), 3);
+    assert_eq!(it.next(), Some(0us));
+    assert_eq!(it.len(), 2);
+    assert_eq!(it.next(), Some(1us));
+    assert_eq!(it.len(), 1);
+    assert_eq!(it.next(), Some(2us));
+    assert_eq!(it.len(), 0);
+    assert_eq!(it.next(), None);
+    assert_eq!(it.len(), 0);
+    assert_eq!(it.next(), None);
+    assert_eq!(it.len(), 0);
+    assert_eq!(it.next(), None);
+    assert_eq!(it.len(), 0);
+}
+
 #[bench]
 fn bench_rposition(b: &mut Bencher) {
     let it: Vec<uint> = range(0u, 300).collect();
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index 8186a4f0904..e0623bade5c 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use core::cmp::PartialEq;
-use core::fmt::Show;
+use core::fmt::Debug;
 use core::num::{NumCast, cast};
 use core::ops::{Add, Sub, Mul, Div, Rem};
 use core::marker::Copy;
@@ -37,7 +37,7 @@ pub fn test_num<T>(ten: T, two: T) where
     T: PartialEq + NumCast
      + Add<Output=T> + Sub<Output=T>
      + Mul<Output=T> + Div<Output=T>
-     + Rem<Output=T> + Show
+     + Rem<Output=T> + Debug
      + Copy
 {
     assert_eq!(ten.add(two),  cast(12i).unwrap());
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index 485549cc552..daccb709890 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -14,11 +14,11 @@ pub fn op2() -> Result<int, &'static str> { Err("sadface") }
 #[test]
 pub fn test_and() {
     assert_eq!(op1().and(Ok(667i)).unwrap(), 667);
-    assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(),
+    assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
                "bad");
 
     assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface");
-    assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(),
+    assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(),
                "sadface");
 }
 
@@ -94,7 +94,7 @@ pub fn test_fmt_default() {
     let err: Result<int, &'static str> = Err("Err");
 
     let s = format!("{:?}", ok);
-    assert_eq!(s, "Ok(100i)");
+    assert_eq!(s, "Ok(100)");
     let s = format!("{:?}", err);
     assert_eq!(s, "Err(\"Err\")");
 }
diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs
index 62eb9f4ad34..e524d8de056 100644
--- a/src/libcoretest/tuple.rs
+++ b/src/libcoretest/tuple.rs
@@ -60,9 +60,9 @@ fn test_tuple_cmp() {
 #[test]
 fn test_show() {
     let s = format!("{:?}", (1i,));
-    assert_eq!(s, "(1i,)");
+    assert_eq!(s, "(1,)");
     let s = format!("{:?}", (1i, true));
-    assert_eq!(s, "(1i, true)");
+    assert_eq!(s, "(1, true)");
     let s = format!("{:?}", (1i, "hi", true));
-    assert_eq!(s, "(1i, \"hi\", true)");
+    assert_eq!(s, "(1, \"hi\", true)");
 }