More test fixes

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase, slicing_syntax, globs, unboxed_closures)]
+#![feature(slicing_syntax, unboxed_closures)]
 
 #![deny(warnings)]
 

src/doc/guide-error-handling.md

@@ -167,10 +167,10 @@ fn parse_version(header: &[u8]) -> Result<Version, ParseError> {
 let version = parse_version(&[1, 2, 3, 4]);
 match version {
     Ok(v) => {
-        println!("working with version: {}", v);
+        println!("working with version: {:?}", v);
     }
     Err(e) => {
-        println!("error parsing header: {}", e);
+        println!("error parsing header: {:?}", e);
     }
 }
 ```

src/doc/guide-macros.md

@@ -42,17 +42,17 @@ the pattern in the above code:
 # let input_1 = T::SpecialA(0);
 # let input_2 = T::SpecialA(0);
 macro_rules! early_return {
-    ($inp:expr $sp:path) => ( // invoke it like `(input_5 SpecialE)`
+    ($inp:expr, $sp:path) => ( // invoke it like `(input_5 SpecialE)`
         match $inp {
             $sp(x) => { return x; }
             _ => {}
         }
     );
 }
 // ...
-early_return!(input_1 T::SpecialA);
+early_return!(input_1, T::SpecialA);
 // ...
-early_return!(input_2 T::SpecialB);
+early_return!(input_2, T::SpecialB);
 # return 0;
 # }
 # fn main() {}

src/doc/guide-pointers.md

@@ -620,7 +620,7 @@ enum List<T> {
 
 fn main() {
     let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil)));
-    println!("{}", list);
+    println!("{:?}", list);
 }
 ```
 

src/liballoc/arc.rs

@@ -41,7 +41,7 @@
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
-//!         println!("{}", five);
+//!         println!("{:?}", five);
 //!     });
 //! }
 //! ```

src/liballoc/lib.rs

@@ -65,7 +65,7 @@
 
 #![no_std]
 #![allow(unknown_features)]
-#![feature(lang_items, phase, unsafe_destructor)]
+#![feature(lang_items, unsafe_destructor)]
 
 #[macro_use]
 extern crate core;

src/libcollections/bit.rs

@@ -143,17 +143,17 @@ static FALSE: bool = false;
 /// bv.set(3, true);
 /// bv.set(5, true);
 /// bv.set(7, true);
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
 /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
 ///
 /// // flip all values in bitvector, producing non-primes less than 10
 /// bv.negate();
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
 /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
 ///
 /// // reset bitvector to empty
 /// bv.clear();
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
 /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
 /// ```
 #[stable]
@@ -1881,10 +1881,10 @@ mod tests {
     #[test]
     fn test_to_str() {
         let zerolen = Bitv::new();
-        assert_eq!(zerolen.to_string(), "");
+        assert_eq!(format!("{:?}", zerolen), "");
 
         let eightbits = Bitv::from_elem(8u, false);
-        assert_eq!(eightbits.to_string(), "00000000")
+        assert_eq!(format!("{:?}", eightbits), "00000000")
     }
 
     #[test]
@@ -1910,7 +1910,7 @@ mod tests {
         let mut b = Bitv::from_elem(2, false);
         b.set(0, true);
         b.set(1, false);
-        assert_eq!(b.to_string(), "10");
+        assert_eq!(format!("{:?}", b), "10");
         assert!(!b.none() && !b.all());
     }
 
@@ -2245,7 +2245,7 @@ mod tests {
     fn test_from_bytes() {
         let bitv = Bitv::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
         let str = concat!("10110110", "00000000", "11111111");
-        assert_eq!(bitv.to_string(), str);
+        assert_eq!(format!("{:?}", bitv), str);
     }
 
     #[test]
@@ -2264,7 +2264,7 @@ mod tests {
     fn test_from_bools() {
         let bools = vec![true, false, true, true];
         let bitv: Bitv = bools.iter().map(|n| *n).collect();
-        assert_eq!(bitv.to_string(), "1011");
+        assert_eq!(format!("{:?}", bitv), "1011");
     }
 
     #[test]
@@ -2622,7 +2622,7 @@ mod bitv_set_test {
         s.insert(10);
         s.insert(50);
         s.insert(2);
-        assert_eq!("{1, 2, 10, 50}", s.to_string());
+        assert_eq!("BitvSet {1u, 2u, 10u, 50u}", format!("{:?}", s));
     }
 
     #[test]

src/libcollections/btree/map.rs

@@ -1347,7 +1347,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     ///
     /// // count the number of occurrences of letters in the vec
     /// for x in vec!["a","b","a","c","a","b"].iter() {
-    ///     match count.entry(x) {
+    ///     match count.entry(*x) {
     ///         Entry::Vacant(view) => {
     ///             view.insert(1);
     ///         },

src/libcollections/btree/set.rs

@@ -842,9 +842,9 @@ mod test {
         set.insert(1);
         set.insert(2);
 
-        let set_str = format!("{}", set);
+        let set_str = format!("{:?}", set);
 
-        assert!(set_str == "{1, 2}");
-        assert_eq!(format!("{}", empty), "{}");
+        assert_eq!(set_str, "BTreeSet {1i, 2i}");
+        assert_eq!(format!("{:?}", empty), "BTreeSet {}");
     }
 }

src/libcollections/dlist.rs

@@ -1018,12 +1018,12 @@ mod tests {
     #[test]
     fn test_show() {
         let list: DList<int> = range(0i, 10).collect();
-        assert!(list.to_string() == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+        assert_eq!(format!("{:?}", list), "DList [0i, 1i, 2i, 3i, 4i, 5i, 6i, 7i, 8i, 9i]");
 
         let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
                                                                    .map(|&s| s)
                                                                    .collect();
-        assert!(list.to_string() == "[just, one, test, more]");
+        assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]");
     }
 
     #[cfg(test)]