From e9cfbc3956cc9f9ccc2f4aa6e127abb9a16ad083 Mon Sep 17 00:00:00 2001 From: skullzzz Date: Wed, 17 Dec 2014 23:36:10 -0500 Subject: [PATCH 1/7] implement fmt traits for collections --- src/libcollections/btree/map.rs | 12 ++ src/libcollections/btree/set.rs | 13 ++ src/libcollections/format_helpers.rs | 257 +++++++++++++++++++++++++++ src/libcollections/lib.rs | 1 + src/libcollections/linked_list.rs | 12 ++ src/libcollections/macros.rs | 42 +++++ src/libcollections/vec.rs | 13 ++ src/libcollections/vec_deque.rs | 24 +-- src/libcollections/vec_map.rs | 21 +-- src/libcore/array.rs | 19 +- src/libcore/fmt/mod.rs | 33 ++++ src/test/run-pass/ifmt.rs | 95 ++++++++++ 12 files changed, 512 insertions(+), 30 deletions(-) create mode 100644 src/libcollections/format_helpers.rs diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 291b66939e5ef..27d4fdbaaad1a 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -29,6 +29,7 @@ use Bound::{self, Included, Excluded, Unbounded}; use borrow::Borrow; use vec_deque::VecDeque; +use format_helpers::*; use self::Continuation::{Continue, Finished}; use self::StackOp::*; @@ -930,6 +931,17 @@ impl Debug for BTreeMap { } } +impl_map_fmt! { + BTreeMap, + Display => map_fmt_display, + Octal => map_fmt_octal, + Binary => map_fmt_binary, + LowerHex => map_fmt_lower_hex, + UpperHex => map_fmt_upper_hex, + LowerExp => map_fmt_lower_exp, + UpperExp => map_fmt_upper_exp +} + #[stable(feature = "rust1", since = "1.0.0")] impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap where K: Borrow, Q: Ord diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index fc346151e0b4b..3de9f90fecfa0 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -23,6 +23,8 @@ use borrow::Borrow; use btree_map::{BTreeMap, Keys}; use Bound; +use format_helpers::*; + // FIXME(conventions): implement bounded iterators /// A set based on a B-Tree. @@ -626,6 +628,17 @@ impl Debug for BTreeSet { } } +impl_set_fmt! { + BTreeSet, + Display => seq_fmt_display, + Octal => seq_fmt_octal, + Binary => seq_fmt_binary, + LowerHex => seq_fmt_lower_hex, + UpperHex => seq_fmt_upper_hex, + LowerExp => seq_fmt_lower_exp, + UpperExp => seq_fmt_upper_exp +} + impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { Iter { iter: self.iter.clone() } } } diff --git a/src/libcollections/format_helpers.rs b/src/libcollections/format_helpers.rs new file mode 100644 index 0000000000000..789bf4a95127a --- /dev/null +++ b/src/libcollections/format_helpers.rs @@ -0,0 +1,257 @@ +// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use core::fmt::{self, Formatter}; +use core::iter::{Iterator}; +use core::result::Result; + +pub fn seq_fmt_debug(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::Debug +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:?}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_display(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::Display +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_octal(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::Octal +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:o}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_binary(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::Binary +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:b}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_upper_hex(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::UpperHex +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:X}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_lower_hex(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::LowerHex +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:x}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_upper_exp(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::UpperExp +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:E}", e)); + } + + Result::Ok(()) +} + +pub fn seq_fmt_lower_exp(s: I, f: &mut Formatter) -> fmt::Result + where I::Item:fmt::LowerExp +{ + for (i, e) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:e}", e)); + } + + Result::Ok(()) +} + +pub fn map_fmt_display>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::Display +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_octal>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Octal, + V:fmt::Octal +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:o}: {:o}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_binary>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Binary, + V:fmt::Binary +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:b}: {:b}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_upper_hex>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::UpperHex, + V:fmt::UpperHex +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:X}: {:X}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_lower_hex>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::LowerHex, + V:fmt::LowerHex +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:x}: {:x}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_upper_exp>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::UpperExp, + V:fmt::UpperExp +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:E}: {:E}", k, v)); + } + + Result::Ok(()) +} + +pub fn map_fmt_lower_exp>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::LowerExp, + V:fmt::LowerExp +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:e}: {:e}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_debug>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::Debug +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {:?}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_display>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::Display +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_octal>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::Octal +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {:o}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_binary>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::Binary +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {:b}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_upper_hex>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::UpperHex +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {:X}", k, v)); + } + + Result::Ok(()) +} + +pub fn vec_map_fmt_lower_hex>(s: I, f: &mut Formatter) -> fmt::Result + where K:fmt::Display, + V:fmt::LowerHex +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{}: {:x}", k, v)); + } + + Result::Ok(()) +} diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index ecbe9369e781f..eee7f7ab45208 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -81,6 +81,7 @@ mod btree; pub mod borrow; pub mod enum_set; pub mod fmt; +mod format_helpers; pub mod linked_list; pub mod range; pub mod slice; diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index f6dc5cf7d90a0..5da9cd8c2e108 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -31,6 +31,7 @@ use core::iter::{self, FromIterator}; use core::mem; use core::ptr; +use format_helpers::*; /// A doubly-linked list. #[stable(feature = "rust1", since = "1.0.0")] pub struct LinkedList { @@ -921,6 +922,17 @@ impl fmt::Debug for LinkedList { } } +impl_seq_fmt! { + LinkedList, + Display => seq_fmt_display, + Octal => seq_fmt_octal, + Binary => seq_fmt_binary, + LowerHex => seq_fmt_lower_hex, + UpperHex => seq_fmt_upper_hex, + LowerExp => seq_fmt_lower_exp, + UpperExp => seq_fmt_upper_exp +} + #[stable(feature = "rust1", since = "1.0.0")] impl Hash for LinkedList { fn hash(&self, state: &mut H) { diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index 5f614f3649ca9..a62861bb2d130 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -75,3 +75,45 @@ macro_rules! vec { macro_rules! format { ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*))) } + +macro_rules! impl_seq_fmt { + ($seq:ident, $($Trait:ident => $fmt_fun:ident),+) => { + $( + impl fmt::$Trait for $seq { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + try!(write!(f, "[")); + try!($fmt_fun(self.iter(), f)); + write!(f, "]") + } + } + )+ + } +} + +macro_rules! impl_set_fmt { + ($seq:ident, $($Trait:ident => $fmt_fun:ident),+) => { + $( + impl fmt::$Trait for $seq { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + try!(write!(f, "{{")); + try!($fmt_fun(self.iter(), f)); + write!(f, "}}") + } + } + )+ + } +} + +macro_rules! impl_map_fmt { + ($map:ident, $($Trait:ident => $fmt_fun:ident),+) => { + $( + impl fmt::$Trait for $map { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + try!(write!(f, "{{")); + try!($fmt_fun(self.iter(), f)); + write!(f, "}}") + } + } + )+ + }; +} diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 66bb84205e21c..556398875df1f 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -82,6 +82,8 @@ use super::range::RangeArgument; // FIXME- fix places which assume the max vector allowed has memory usize::MAX. static MAX_MEMORY_SIZE: usize = isize::MAX as usize; +use format_helpers::*; + /// A growable list type, written `Vec` but pronounced 'vector.' /// /// # Examples @@ -1653,6 +1655,17 @@ impl fmt::Debug for Vec { } } +impl_seq_fmt! { + Vec, + Display => seq_fmt_display, + Octal => seq_fmt_octal, + Binary => seq_fmt_binary, + LowerHex => seq_fmt_lower_hex, + UpperHex => seq_fmt_upper_hex, + LowerExp => seq_fmt_lower_exp, + UpperExp => seq_fmt_upper_exp +} + #[stable(feature = "rust1", since = "1.0.0")] impl AsRef> for Vec { fn as_ref(&self) -> &Vec { diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index f70906f84b869..97ccb9fb0d3f2 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -32,6 +32,8 @@ use core::hash::{Hash, Hasher}; use core::cmp; use alloc::heap; +use format_helpers::*; + const INITIAL_CAPACITY: usize = 7; // 2^3 - 1 const MINIMUM_CAPACITY: usize = 1; // 2 - 1 @@ -1791,18 +1793,16 @@ impl Extend for VecDeque { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for VecDeque { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "[")); - - for (i, e) in self.iter().enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{:?}", *e)); - } - - write!(f, "]") - } +impl_seq_fmt! { + VecDeque, + Debug => seq_fmt_debug, + Display => seq_fmt_display, + Octal => seq_fmt_octal, + Binary => seq_fmt_binary, + LowerHex => seq_fmt_lower_hex, + UpperHex => seq_fmt_upper_hex, + LowerExp => seq_fmt_lower_exp, + UpperExp => seq_fmt_upper_exp } #[cfg(test)] diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index aa0ab41b7455b..5af52d3c140d1 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -27,6 +27,7 @@ use core::ops::{Index, IndexMut}; use {vec, slice}; use vec::Vec; +use format_helpers::*; /// A map optimized for small integer keys. /// @@ -742,18 +743,14 @@ impl Ord for VecMap { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for VecMap { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(write!(f, "{{")); - - for (i, (k, v)) in self.iter().enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:?}", k, *v)); - } - - write!(f, "}}") - } +impl_set_fmt! { + VecMap, + Debug => vec_map_fmt_debug, + Display => vec_map_fmt_display, + Octal => vec_map_fmt_octal, + Binary => vec_map_fmt_binary, + LowerHex => vec_map_fmt_lower_hex, + UpperHex => vec_map_fmt_upper_hex } #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 91301ee558ca5..427d87f61d6a3 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -38,6 +38,18 @@ pub trait FixedSizeArray { fn as_mut_slice(&mut self) -> &mut [T]; } +macro_rules! fmt_array { + ($N:expr, $($Trait:ident),*) => { + $( + impl fmt::$Trait for [T; $N] { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::$Trait::fmt(&&self[..], f) + } + } + )* + } +} + // macro for implementing n-ary tuple functions and operations macro_rules! array_impls { ($($N:expr)+) => { @@ -86,12 +98,7 @@ macro_rules! array_impls { } } - #[stable(feature = "rust1", since = "1.0.0")] - impl fmt::Debug for [T; $N] { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&&self[..], f) - } - } + fmt_array! { $N, Debug, Display, Octal, Binary, UpperHex, LowerHex, UpperExp, LowerExp } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> IntoIterator for &'a [T; $N] { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index a87f6619fe877..60588ce165388 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -1124,6 +1124,39 @@ impl Debug for [T] { } } +macro_rules! fmt_dst { + ($($Trait:ident => $fmt_char:expr),*) => { + $( + impl $Trait for [T] { + fn fmt(&self, f: &mut Formatter) -> Result { + try!(write!(f, "[")); + let mut is_first = true; + for x in self.iter() { + if is_first { + is_first = false; + } else { + try!(write!(f, ", ")); + } + try!(write!(f, $fmt_char, *x)); + } + write!(f, "]") + } + } + )* + } +} + +fmt_dst! { + Display => "{}", + Octal => "{:o}", + Binary => "{:b}", + UpperHex => "{:X}", + LowerHex => "{:x}", + UpperExp => "{:E}", + LowerExp => "{:e}" +} + + #[stable(feature = "rust1", since = "1.0.0")] impl Debug for () { fn fmt(&self, f: &mut Formatter) -> Result { diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 240b6286c8cfc..1d44ab951d03f 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -181,6 +181,8 @@ pub fn main() { // test that trailing commas are acceptable format!("{}", "test",); format!("{foo}", foo="test",); + + test_collections(); } // Basic test to make sure that we can invoke the `write!` macro with an @@ -246,3 +248,96 @@ fn test_order() { foo(), foo(), foo(), a=foo(), b=foo(), c=foo()), "1 2 4 5 3 6".to_string()); } + +fn test_collections() { + use std::collections::{LinkedList, VecDeque, BTreeSet, BTreeMap}; + + let u32_array = [10u32, 20, 64, 255, 0xffffffff]; + t!(format!("{}", u32_array), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_array), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_array), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_array = [10f32, 20.0 , 64.0, 255.0]; + t!(format!("{}", f32_array), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_vec = vec![10u32, 20, 64, 255, 0xffffffff]; + t!(format!("{}", u32_vec), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_vec), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_vec), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_vec = vec![10f32, 20.0 , 64.0, 255.0]; + t!(format!("{}", f32_vec), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_dlist:LinkedList<_> = u32_vec.into_iter().collect(); + t!(format!("{}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_dlist), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_dlist), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_dlist), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_dlist), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_dlist:LinkedList<_> = f32_vec.into_iter().collect(); + t!(format!("{}", f32_dlist), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_dlist), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_dlist), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_dlist), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_ring_buf:VecDeque<_> = u32_dlist.into_iter().collect(); + t!(format!("{}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_ring_buf), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_ring_buf), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_ring_buf:VecDeque<_> = f32_dlist.into_iter().collect(); + t!(format!("{}", f32_ring_buf), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_btree_set:BTreeSet<_> = u32_ring_buf.into_iter().collect(); + t!(format!("{}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); + t!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); + t!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); + t!(format!("{:b}", u32_btree_set), + "{1010, 10100, 1000000, 11111111, 11111111111111111111111111111111}"); + t!(format!("{:x}", u32_btree_set), "{a, 14, 40, ff, ffffffff}"); + t!(format!("{:X}", u32_btree_set), "{A, 14, 40, FF, FFFFFFFF}"); + + let mut u32_btree_map:BTreeMap = BTreeMap::new(); + for x in u32_btree_set.iter() { + u32_btree_map.insert(*x, *x); + }; + + t!(format!("{}", u32_btree_map), + "{10: 10, 20: 20, 64: 64, 255: 255, 4294967295: 4294967295}"); + t!(format!("{:?}", u32_btree_map), + "{10: 10, 20: 20, 64: 64, \ + 255: 255, 4294967295: 4294967295}"); + t!(format!("{:o}", u32_btree_map), + "{12: 12, 24: 24, 100: 100, 377: 377, 37777777777: 37777777777}"); + t!(format!("{:b}", u32_btree_map), + "{1010: 1010, 10100: 10100, 1000000: 1000000, 11111111: 11111111, \ + 11111111111111111111111111111111: 11111111111111111111111111111111}"); + t!(format!("{:x}", u32_btree_map), + "{a: a, 14: 14, 40: 40, ff: ff, ffffffff: ffffffff}"); + t!(format!("{:X}", u32_btree_map), + "{A: A, 14: 14, 40: 40, FF: FF, FFFFFFFF: FFFFFFFF}"); +} From 00ea4a1743ce85b77c9f574acc832edb6bc5ac97 Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 19:49:44 -0400 Subject: [PATCH 2/7] rename fmt_dst macro to fmt_slice and use iter.enumerate() in loop --- src/libcore/fmt/mod.rs | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 60588ce165388..51d6dc9c76a2e 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -1124,19 +1124,14 @@ impl Debug for [T] { } } -macro_rules! fmt_dst { +macro_rules! fmt_slice { ($($Trait:ident => $fmt_char:expr),*) => { $( impl $Trait for [T] { fn fmt(&self, f: &mut Formatter) -> Result { try!(write!(f, "[")); - let mut is_first = true; - for x in self.iter() { - if is_first { - is_first = false; - } else { - try!(write!(f, ", ")); - } + for (i, x) in self.iter().enumerate() { + if i != 0 { try!(write!(f, ", ")); } try!(write!(f, $fmt_char, *x)); } write!(f, "]") @@ -1146,7 +1141,7 @@ macro_rules! fmt_dst { } } -fmt_dst! { +fmt_slice! { Display => "{}", Octal => "{:o}", Binary => "{:b}", From fc6e5053a2d88a705b4451217822e14a60d01cdd Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 19:50:50 -0400 Subject: [PATCH 3/7] remove vec_map_fmt helpers --- src/libcollections/format_helpers.rs | 127 +++++++-------------------- src/libcollections/vec_map.rs | 12 +-- 2 files changed, 40 insertions(+), 99 deletions(-) diff --git a/src/libcollections/format_helpers.rs b/src/libcollections/format_helpers.rs index 789bf4a95127a..b5216b51de616 100644 --- a/src/libcollections/format_helpers.rs +++ b/src/libcollections/format_helpers.rs @@ -13,7 +13,7 @@ use core::iter::{Iterator}; use core::result::Result; pub fn seq_fmt_debug(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::Debug + where I::Item: fmt::Debug { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -24,7 +24,7 @@ pub fn seq_fmt_debug(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_display(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::Display + where I::Item: fmt::Display { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -35,7 +35,7 @@ pub fn seq_fmt_display(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_octal(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::Octal + where I::Item: fmt::Octal { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -46,7 +46,7 @@ pub fn seq_fmt_octal(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_binary(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::Binary + where I::Item: fmt::Binary { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -57,7 +57,7 @@ pub fn seq_fmt_binary(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_upper_hex(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::UpperHex + where I::Item: fmt::UpperHex { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -68,7 +68,7 @@ pub fn seq_fmt_upper_hex(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_lower_hex(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::LowerHex + where I::Item: fmt::LowerHex { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -79,7 +79,7 @@ pub fn seq_fmt_lower_hex(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_upper_exp(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::UpperExp + where I::Item: fmt::UpperExp { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -90,7 +90,7 @@ pub fn seq_fmt_upper_exp(s: I, f: &mut Formatter) -> fmt::Result } pub fn seq_fmt_lower_exp(s: I, f: &mut Formatter) -> fmt::Result - where I::Item:fmt::LowerExp + where I::Item: fmt::LowerExp { for (i, e) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -100,9 +100,21 @@ pub fn seq_fmt_lower_exp(s: I, f: &mut Formatter) -> fmt::Result Result::Ok(()) } +pub fn map_fmt_debug>(s: I, f: &mut Formatter) -> fmt::Result + where K: fmt::Debug, + V: fmt::Debug +{ + for (i, (k, v)) in s.enumerate() { + if i != 0 { try!(write!(f, ", ")); } + try!(write!(f, "{:?}: {:?}", k, v)); + } + + Result::Ok(()) +} + pub fn map_fmt_display>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::Display + where K: fmt::Display, + V: fmt::Display { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -113,8 +125,8 @@ pub fn map_fmt_display>(s: I, f: &mut Formatter) } pub fn map_fmt_octal>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Octal, - V:fmt::Octal + where K: fmt::Octal, + V: fmt::Octal { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -125,8 +137,8 @@ pub fn map_fmt_octal>(s: I, f: &mut Formatter) -> } pub fn map_fmt_binary>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Binary, - V:fmt::Binary + where K: fmt::Binary, + V: fmt::Binary { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -137,8 +149,8 @@ pub fn map_fmt_binary>(s: I, f: &mut Formatter) - } pub fn map_fmt_upper_hex>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::UpperHex, - V:fmt::UpperHex + where K: fmt::UpperHex, + V: fmt::UpperHex { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -149,8 +161,8 @@ pub fn map_fmt_upper_hex>(s: I, f: &mut Formatter } pub fn map_fmt_lower_hex>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::LowerHex, - V:fmt::LowerHex + where K: fmt::LowerHex, + V: fmt::LowerHex { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -161,8 +173,8 @@ pub fn map_fmt_lower_hex>(s: I, f: &mut Formatter } pub fn map_fmt_upper_exp>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::UpperExp, - V:fmt::UpperExp + where K: fmt::UpperExp, + V: fmt::UpperExp { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -173,8 +185,8 @@ pub fn map_fmt_upper_exp>(s: I, f: &mut Formatter } pub fn map_fmt_lower_exp>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::LowerExp, - V:fmt::LowerExp + where K: fmt::LowerExp, + V: fmt::LowerExp { for (i, (k, v)) in s.enumerate() { if i != 0 { try!(write!(f, ", ")); } @@ -184,74 +196,3 @@ pub fn map_fmt_lower_exp>(s: I, f: &mut Formatter Result::Ok(()) } -pub fn vec_map_fmt_debug>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::Debug -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:?}", k, v)); - } - - Result::Ok(()) -} - -pub fn vec_map_fmt_display>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::Display -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {}", k, v)); - } - - Result::Ok(()) -} - -pub fn vec_map_fmt_octal>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::Octal -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:o}", k, v)); - } - - Result::Ok(()) -} - -pub fn vec_map_fmt_binary>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::Binary -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:b}", k, v)); - } - - Result::Ok(()) -} - -pub fn vec_map_fmt_upper_hex>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::UpperHex -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:X}", k, v)); - } - - Result::Ok(()) -} - -pub fn vec_map_fmt_lower_hex>(s: I, f: &mut Formatter) -> fmt::Result - where K:fmt::Display, - V:fmt::LowerHex -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {:x}", k, v)); - } - - Result::Ok(()) -} diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 5af52d3c140d1..609bdea121ab1 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -745,12 +745,12 @@ impl Ord for VecMap { impl_set_fmt! { VecMap, - Debug => vec_map_fmt_debug, - Display => vec_map_fmt_display, - Octal => vec_map_fmt_octal, - Binary => vec_map_fmt_binary, - LowerHex => vec_map_fmt_lower_hex, - UpperHex => vec_map_fmt_upper_hex + Debug => map_fmt_debug, + Display => map_fmt_display, + Octal => map_fmt_octal, + Binary => map_fmt_binary, + LowerHex => map_fmt_lower_hex, + UpperHex => map_fmt_upper_hex } #[stable(feature = "rust1", since = "1.0.0")] From d10fecd0a3f0a15f3e38fac1993cc361fe66134d Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 19:51:12 -0400 Subject: [PATCH 4/7] move tests to libcollectionstest --- src/libcollectionstest/fmt.rs | 91 +++++++++++++++++++++++++++++++++ src/test/run-pass/ifmt.rs | 94 ----------------------------------- 2 files changed, 91 insertions(+), 94 deletions(-) diff --git a/src/libcollectionstest/fmt.rs b/src/libcollectionstest/fmt.rs index 70e21c65a1806..930cc67fb19d1 100644 --- a/src/libcollectionstest/fmt.rs +++ b/src/libcollectionstest/fmt.rs @@ -9,9 +9,100 @@ // except according to those terms. use std::fmt; +use std::collections::{LinkedList, VecDeque, BTreeSet, BTreeMap}; + #[test] fn test_format() { let s = fmt::format(format_args!("Hello, {}!", "world")); assert_eq!(s, "Hello, world!"); + + let u32_array = [10u32, 20, 64, 255, 0xffffffff]; + t!(format!("{}", u32_array), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_array), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_array), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_array = [10f32, 20.0 , 64.0, 255.0]; + t!(format!("{}", f32_array), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_vec = vec![10u32, 20, 64, 255, 0xffffffff]; + t!(format!("{}", u32_vec), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_vec), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_vec), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_vec = vec![10f32, 20.0 , 64.0, 255.0]; + t!(format!("{}", f32_vec), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_dlist: LinkedList<_> = u32_vec.into_iter().collect(); + t!(format!("{}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_dlist), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_dlist), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_dlist), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_dlist), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_dlist: LinkedList<_> = f32_vec.into_iter().collect(); + t!(format!("{}", f32_dlist), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_dlist), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_dlist), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_dlist), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_ring_buf: VecDeque<_> = u32_dlist.into_iter().collect(); + t!(format!("{}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); + t!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); + t!(format!("{:b}", u32_ring_buf), + "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); + t!(format!("{:x}", u32_ring_buf), "[a, 14, 40, ff, ffffffff]"); + t!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_ring_buf: VecDeque<_> = f32_dlist.into_iter().collect(); + t!(format!("{}", f32_ring_buf), "[10, 20, 64, 255]"); + t!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); + t!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); + t!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_btree_set: BTreeSet<_> = u32_ring_buf.into_iter().collect(); + t!(format!("{}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); + t!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); + t!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); + t!(format!("{:b}", u32_btree_set), + "{1010, 10100, 1000000, 11111111, 11111111111111111111111111111111}"); + t!(format!("{:x}", u32_btree_set), "{a, 14, 40, ff, ffffffff}"); + t!(format!("{:X}", u32_btree_set), "{A, 14, 40, FF, FFFFFFFF}"); + + let mut u32_btree_map: BTreeMap = BTreeMap::new(); + for x in u32_btree_set.iter() { + u32_btree_map.insert(*x, *x); + }; + + t!(format!("{}", u32_btree_map), + "{10: 10, 20: 20, 64: 64, 255: 255, 4294967295: 4294967295}"); + t!(format!("{:?}", u32_btree_map), + "{10: 10, 20: 20, 64: 64, \ + 255: 255, 4294967295: 4294967295}"); + t!(format!("{:o}", u32_btree_map), + "{12: 12, 24: 24, 100: 100, 377: 377, 37777777777: 37777777777}"); + t!(format!("{:b}", u32_btree_map), + "{1010: 1010, 10100: 10100, 1000000: 1000000, 11111111: 11111111, \ + 11111111111111111111111111111111: 11111111111111111111111111111111}"); + t!(format!("{:x}", u32_btree_map), + "{a: a, 14: 14, 40: 40, ff: ff, ffffffff: ffffffff}"); + t!(format!("{:X}", u32_btree_map), + "{A: A, 14: 14, 40: 40, FF: FF, FFFFFFFF: FFFFFFFF}"); } diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 1d44ab951d03f..26f6fc4161822 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -181,8 +181,6 @@ pub fn main() { // test that trailing commas are acceptable format!("{}", "test",); format!("{foo}", foo="test",); - - test_collections(); } // Basic test to make sure that we can invoke the `write!` macro with an @@ -249,95 +247,3 @@ fn test_order() { "1 2 4 5 3 6".to_string()); } -fn test_collections() { - use std::collections::{LinkedList, VecDeque, BTreeSet, BTreeMap}; - - let u32_array = [10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{}", u32_array), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_array), - "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_array), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); - - let f32_array = [10f32, 20.0 , 64.0, 255.0]; - t!(format!("{}", f32_array), "[10, 20, 64, 255]"); - t!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_vec = vec![10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{}", u32_vec), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_vec), - "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_vec), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); - - let f32_vec = vec![10f32, 20.0 , 64.0, 255.0]; - t!(format!("{}", f32_vec), "[10, 20, 64, 255]"); - t!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_dlist:LinkedList<_> = u32_vec.into_iter().collect(); - t!(format!("{}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:?}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_dlist), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_dlist), - "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_dlist), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_dlist), "[A, 14, 40, FF, FFFFFFFF]"); - - let f32_dlist:LinkedList<_> = f32_vec.into_iter().collect(); - t!(format!("{}", f32_dlist), "[10, 20, 64, 255]"); - t!(format!("{:?}", f32_dlist), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_dlist), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_dlist), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_ring_buf:VecDeque<_> = u32_dlist.into_iter().collect(); - t!(format!("{}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_ring_buf), - "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_ring_buf), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); - - let f32_ring_buf:VecDeque<_> = f32_dlist.into_iter().collect(); - t!(format!("{}", f32_ring_buf), "[10, 20, 64, 255]"); - t!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_btree_set:BTreeSet<_> = u32_ring_buf.into_iter().collect(); - t!(format!("{}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); - t!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); - t!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); - t!(format!("{:b}", u32_btree_set), - "{1010, 10100, 1000000, 11111111, 11111111111111111111111111111111}"); - t!(format!("{:x}", u32_btree_set), "{a, 14, 40, ff, ffffffff}"); - t!(format!("{:X}", u32_btree_set), "{A, 14, 40, FF, FFFFFFFF}"); - - let mut u32_btree_map:BTreeMap = BTreeMap::new(); - for x in u32_btree_set.iter() { - u32_btree_map.insert(*x, *x); - }; - - t!(format!("{}", u32_btree_map), - "{10: 10, 20: 20, 64: 64, 255: 255, 4294967295: 4294967295}"); - t!(format!("{:?}", u32_btree_map), - "{10: 10, 20: 20, 64: 64, \ - 255: 255, 4294967295: 4294967295}"); - t!(format!("{:o}", u32_btree_map), - "{12: 12, 24: 24, 100: 100, 377: 377, 37777777777: 37777777777}"); - t!(format!("{:b}", u32_btree_map), - "{1010: 1010, 10100: 10100, 1000000: 1000000, 11111111: 11111111, \ - 11111111111111111111111111111111: 11111111111111111111111111111111}"); - t!(format!("{:x}", u32_btree_map), - "{a: a, 14: 14, 40: 40, ff: ff, ffffffff: ffffffff}"); - t!(format!("{:X}", u32_btree_map), - "{A: A, 14: 14, 40: 40, FF: FF, FFFFFFFF: FFFFFFFF}"); -} From 5ef7141e5c3ebcd2e3106b1e7d653dda29fe585d Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 20:14:19 -0400 Subject: [PATCH 5/7] remove all Display implementations --- src/libcollections/btree/map.rs | 1 - src/libcollections/btree/set.rs | 1 - src/libcollections/format_helpers.rs | 23 ----------------------- src/libcollections/linked_list.rs | 1 - src/libcollections/vec.rs | 1 - src/libcollections/vec_deque.rs | 1 - src/libcollections/vec_map.rs | 1 - src/libcollectionstest/fmt.rs | 11 ----------- src/libcore/array.rs | 2 +- src/libcore/fmt/mod.rs | 1 - 10 files changed, 1 insertion(+), 42 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 27d4fdbaaad1a..b42f68503aac6 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -933,7 +933,6 @@ impl Debug for BTreeMap { impl_map_fmt! { BTreeMap, - Display => map_fmt_display, Octal => map_fmt_octal, Binary => map_fmt_binary, LowerHex => map_fmt_lower_hex, diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 3de9f90fecfa0..67574802a46a2 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -630,7 +630,6 @@ impl Debug for BTreeSet { impl_set_fmt! { BTreeSet, - Display => seq_fmt_display, Octal => seq_fmt_octal, Binary => seq_fmt_binary, LowerHex => seq_fmt_lower_hex, diff --git a/src/libcollections/format_helpers.rs b/src/libcollections/format_helpers.rs index b5216b51de616..31a808f147694 100644 --- a/src/libcollections/format_helpers.rs +++ b/src/libcollections/format_helpers.rs @@ -23,17 +23,6 @@ pub fn seq_fmt_debug(s: I, f: &mut Formatter) -> fmt::Result Result::Ok(()) } -pub fn seq_fmt_display(s: I, f: &mut Formatter) -> fmt::Result - where I::Item: fmt::Display -{ - for (i, e) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}", e)); - } - - Result::Ok(()) -} - pub fn seq_fmt_octal(s: I, f: &mut Formatter) -> fmt::Result where I::Item: fmt::Octal { @@ -112,18 +101,6 @@ pub fn map_fmt_debug>(s: I, f: &mut Formatter) -> Result::Ok(()) } -pub fn map_fmt_display>(s: I, f: &mut Formatter) -> fmt::Result - where K: fmt::Display, - V: fmt::Display -{ - for (i, (k, v)) in s.enumerate() { - if i != 0 { try!(write!(f, ", ")); } - try!(write!(f, "{}: {}", k, v)); - } - - Result::Ok(()) -} - pub fn map_fmt_octal>(s: I, f: &mut Formatter) -> fmt::Result where K: fmt::Octal, V: fmt::Octal diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index 5da9cd8c2e108..bbcf500cd3bd7 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -924,7 +924,6 @@ impl fmt::Debug for LinkedList { impl_seq_fmt! { LinkedList, - Display => seq_fmt_display, Octal => seq_fmt_octal, Binary => seq_fmt_binary, LowerHex => seq_fmt_lower_hex, diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 556398875df1f..786896aa50156 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1657,7 +1657,6 @@ impl fmt::Debug for Vec { impl_seq_fmt! { Vec, - Display => seq_fmt_display, Octal => seq_fmt_octal, Binary => seq_fmt_binary, LowerHex => seq_fmt_lower_hex, diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index 97ccb9fb0d3f2..94d8ffde645df 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -1796,7 +1796,6 @@ impl Extend for VecDeque { impl_seq_fmt! { VecDeque, Debug => seq_fmt_debug, - Display => seq_fmt_display, Octal => seq_fmt_octal, Binary => seq_fmt_binary, LowerHex => seq_fmt_lower_hex, diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 609bdea121ab1..65f68ec29191d 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -746,7 +746,6 @@ impl Ord for VecMap { impl_set_fmt! { VecMap, Debug => map_fmt_debug, - Display => map_fmt_display, Octal => map_fmt_octal, Binary => map_fmt_binary, LowerHex => map_fmt_lower_hex, diff --git a/src/libcollectionstest/fmt.rs b/src/libcollectionstest/fmt.rs index 930cc67fb19d1..2bcc8cb826ffb 100644 --- a/src/libcollectionstest/fmt.rs +++ b/src/libcollectionstest/fmt.rs @@ -18,7 +18,6 @@ fn test_format() { assert_eq!(s, "Hello, world!"); let u32_array = [10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{}", u32_array), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); t!(format!("{:b}", u32_array), @@ -27,13 +26,11 @@ fn test_format() { t!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); let f32_array = [10f32, 20.0 , 64.0, 255.0]; - t!(format!("{}", f32_array), "[10, 20, 64, 255]"); t!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); t!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); t!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_vec = vec![10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{}", u32_vec), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); t!(format!("{:b}", u32_vec), @@ -42,13 +39,11 @@ fn test_format() { t!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); let f32_vec = vec![10f32, 20.0 , 64.0, 255.0]; - t!(format!("{}", f32_vec), "[10, 20, 64, 255]"); t!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); t!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); t!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_dlist: LinkedList<_> = u32_vec.into_iter().collect(); - t!(format!("{}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:?}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:o}", u32_dlist), "[12, 24, 100, 377, 37777777777]"); t!(format!("{:b}", u32_dlist), @@ -57,13 +52,11 @@ fn test_format() { t!(format!("{:X}", u32_dlist), "[A, 14, 40, FF, FFFFFFFF]"); let f32_dlist: LinkedList<_> = f32_vec.into_iter().collect(); - t!(format!("{}", f32_dlist), "[10, 20, 64, 255]"); t!(format!("{:?}", f32_dlist), "[10, 20, 64, 255]"); t!(format!("{:e}", f32_dlist), "[1e1, 2e1, 6.4e1, 2.55e2]"); t!(format!("{:E}", f32_dlist), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_ring_buf: VecDeque<_> = u32_dlist.into_iter().collect(); - t!(format!("{}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); t!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); t!(format!("{:b}", u32_ring_buf), @@ -72,13 +65,11 @@ fn test_format() { t!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); let f32_ring_buf: VecDeque<_> = f32_dlist.into_iter().collect(); - t!(format!("{}", f32_ring_buf), "[10, 20, 64, 255]"); t!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); t!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); t!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_btree_set: BTreeSet<_> = u32_ring_buf.into_iter().collect(); - t!(format!("{}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); t!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); t!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); t!(format!("{:b}", u32_btree_set), @@ -91,8 +82,6 @@ fn test_format() { u32_btree_map.insert(*x, *x); }; - t!(format!("{}", u32_btree_map), - "{10: 10, 20: 20, 64: 64, 255: 255, 4294967295: 4294967295}"); t!(format!("{:?}", u32_btree_map), "{10: 10, 20: 20, 64: 64, \ 255: 255, 4294967295: 4294967295}"); diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 427d87f61d6a3..99018000710ec 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -98,7 +98,7 @@ macro_rules! array_impls { } } - fmt_array! { $N, Debug, Display, Octal, Binary, UpperHex, LowerHex, UpperExp, LowerExp } + fmt_array! { $N, Debug, Octal, Binary, UpperHex, LowerHex, UpperExp, LowerExp } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> IntoIterator for &'a [T; $N] { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 51d6dc9c76a2e..023ff9e38a633 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -1142,7 +1142,6 @@ macro_rules! fmt_slice { } fmt_slice! { - Display => "{}", Octal => "{:o}", Binary => "{:b}", UpperHex => "{:X}", From 67ae16d73473bf5c02845339ac52e1e930056f43 Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 23:16:15 -0400 Subject: [PATCH 6/7] add vec_map format test --- src/libcollectionstest/fmt.rs | 117 +++++++++++++++++++--------------- 1 file changed, 64 insertions(+), 53 deletions(-) diff --git a/src/libcollectionstest/fmt.rs b/src/libcollectionstest/fmt.rs index 2bcc8cb826ffb..bccaf28d7b30d 100644 --- a/src/libcollectionstest/fmt.rs +++ b/src/libcollectionstest/fmt.rs @@ -9,7 +9,7 @@ // except according to those terms. use std::fmt; -use std::collections::{LinkedList, VecDeque, BTreeSet, BTreeMap}; +use std::collections::{BTreeMap, BTreeSet, LinkedList, VecDeque, VecMap}; #[test] @@ -18,80 +18,91 @@ fn test_format() { assert_eq!(s, "Hello, world!"); let u32_array = [10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_array), + assert_eq!(format!("{:?}", u32_array), "[10, 20, 64, 255, 4294967295]"); + assert_eq!(format!("{:o}", u32_array), "[12, 24, 100, 377, 37777777777]"); + assert_eq!(format!("{:b}", u32_array), "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_array), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); + assert_eq!(format!("{:x}", u32_array), "[a, 14, 40, ff, ffffffff]"); + assert_eq!(format!("{:X}", u32_array), "[A, 14, 40, FF, FFFFFFFF]"); let f32_array = [10f32, 20.0 , 64.0, 255.0]; - t!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); + assert_eq!(format!("{:?}", f32_array), "[10, 20, 64, 255]"); + assert_eq!(format!("{:e}", f32_array), "[1e1, 2e1, 6.4e1, 2.55e2]"); + assert_eq!(format!("{:E}", f32_array), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_vec = vec![10u32, 20, 64, 255, 0xffffffff]; - t!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_vec), + assert_eq!(format!("{:?}", u32_vec), "[10, 20, 64, 255, 4294967295]"); + assert_eq!(format!("{:o}", u32_vec), "[12, 24, 100, 377, 37777777777]"); + assert_eq!(format!("{:b}", u32_vec), "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_vec), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); + assert_eq!(format!("{:x}", u32_vec), "[a, 14, 40, ff, ffffffff]"); + assert_eq!(format!("{:X}", u32_vec), "[A, 14, 40, FF, FFFFFFFF]"); let f32_vec = vec![10f32, 20.0 , 64.0, 255.0]; - t!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_dlist: LinkedList<_> = u32_vec.into_iter().collect(); - t!(format!("{:?}", u32_dlist), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_dlist), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_dlist), + assert_eq!(format!("{:?}", f32_vec), "[10, 20, 64, 255]"); + assert_eq!(format!("{:e}", f32_vec), "[1e1, 2e1, 6.4e1, 2.55e2]"); + assert_eq!(format!("{:E}", f32_vec), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let u32_linked_list: LinkedList<_> = u32_vec.into_iter().collect(); + assert_eq!(format!("{:?}", u32_linked_list), "[10, 20, 64, 255, 4294967295]"); + assert_eq!(format!("{:o}", u32_linked_list), "[12, 24, 100, 377, 37777777777]"); + assert_eq!(format!("{:b}", u32_linked_list), "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_dlist), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_dlist), "[A, 14, 40, FF, FFFFFFFF]"); - - let f32_dlist: LinkedList<_> = f32_vec.into_iter().collect(); - t!(format!("{:?}", f32_dlist), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_dlist), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_dlist), "[1E1, 2E1, 6.4E1, 2.55E2]"); - - let u32_ring_buf: VecDeque<_> = u32_dlist.into_iter().collect(); - t!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); - t!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); - t!(format!("{:b}", u32_ring_buf), + assert_eq!(format!("{:x}", u32_linked_list), "[a, 14, 40, ff, ffffffff]"); + assert_eq!(format!("{:X}", u32_linked_list), "[A, 14, 40, FF, FFFFFFFF]"); + + let f32_linked_list: LinkedList<_> = f32_vec.into_iter().collect(); + assert_eq!(format!("{:?}", f32_linked_list), "[10, 20, 64, 255]"); + assert_eq!(format!("{:e}", f32_linked_list), "[1e1, 2e1, 6.4e1, 2.55e2]"); + assert_eq!(format!("{:E}", f32_linked_list), "[1E1, 2E1, 6.4E1, 2.55E2]"); + + let mut u32_vec_map: VecMap = VecMap::new(); + for (i, x) in u32_linked_list.into_iter().enumerate() { + u32_vec_map.insert(i, x); + } + + assert_eq!(format!("{:?}", u32_vec_map), "{0: 10, 1: 20, 2: 64, 3: 255, 4: 4294967295}"); + assert_eq!(format!("{:o}", u32_vec_map), "{0: 12, 1: 24, 2: 100, 3: 377, 4: 37777777777}"); + assert_eq!(format!("{:b}", u32_vec_map), + "{0: 1010, 1: 10100, 2: 1000000, 3: 11111111, 4: 11111111111111111111111111111111}"); + assert_eq!(format!("{:x}", u32_vec_map), "{0: a, 1: 14, 2: 40, 3: ff, 4: ffffffff}"); + assert_eq!(format!("{:X}", u32_vec_map), "{0: A, 1: 14, 2: 40, 3: FF, 4: FFFFFFFF}"); + + let u32_ring_buf: VecDeque<_> = u32_vec_map.values().collect(); + assert_eq!(format!("{:?}", u32_ring_buf), "[10, 20, 64, 255, 4294967295]"); + assert_eq!(format!("{:o}", u32_ring_buf), "[12, 24, 100, 377, 37777777777]"); + assert_eq!(format!("{:b}", u32_ring_buf), "[1010, 10100, 1000000, 11111111, 11111111111111111111111111111111]"); - t!(format!("{:x}", u32_ring_buf), "[a, 14, 40, ff, ffffffff]"); - t!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); + assert_eq!(format!("{:x}", u32_ring_buf), "[a, 14, 40, ff, ffffffff]"); + assert_eq!(format!("{:X}", u32_ring_buf), "[A, 14, 40, FF, FFFFFFFF]"); - let f32_ring_buf: VecDeque<_> = f32_dlist.into_iter().collect(); - t!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); - t!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); - t!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); + let f32_ring_buf: VecDeque<_> = f32_linked_list.into_iter().collect(); + assert_eq!(format!("{:?}", f32_ring_buf), "[10, 20, 64, 255]"); + assert_eq!(format!("{:e}", f32_ring_buf), "[1e1, 2e1, 6.4e1, 2.55e2]"); + assert_eq!(format!("{:E}", f32_ring_buf), "[1E1, 2E1, 6.4E1, 2.55E2]"); let u32_btree_set: BTreeSet<_> = u32_ring_buf.into_iter().collect(); - t!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); - t!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); - t!(format!("{:b}", u32_btree_set), + assert_eq!(format!("{:?}", u32_btree_set), "{10, 20, 64, 255, 4294967295}"); + assert_eq!(format!("{:o}", u32_btree_set), "{12, 24, 100, 377, 37777777777}"); + assert_eq!(format!("{:b}", u32_btree_set), "{1010, 10100, 1000000, 11111111, 11111111111111111111111111111111}"); - t!(format!("{:x}", u32_btree_set), "{a, 14, 40, ff, ffffffff}"); - t!(format!("{:X}", u32_btree_set), "{A, 14, 40, FF, FFFFFFFF}"); + assert_eq!(format!("{:x}", u32_btree_set), "{a, 14, 40, ff, ffffffff}"); + assert_eq!(format!("{:X}", u32_btree_set), "{A, 14, 40, FF, FFFFFFFF}"); let mut u32_btree_map: BTreeMap = BTreeMap::new(); - for x in u32_btree_set.iter() { + for x in u32_btree_set { u32_btree_map.insert(*x, *x); }; - t!(format!("{:?}", u32_btree_map), - "{10: 10, 20: 20, 64: 64, \ - 255: 255, 4294967295: 4294967295}"); - t!(format!("{:o}", u32_btree_map), + assert_eq!(format!("{:?}", u32_btree_map), + "{10: 10, 20: 20, 64: 64, 255: 255, 4294967295: 4294967295}"); + assert_eq!(format!("{:o}", u32_btree_map), "{12: 12, 24: 24, 100: 100, 377: 377, 37777777777: 37777777777}"); - t!(format!("{:b}", u32_btree_map), + assert_eq!(format!("{:b}", u32_btree_map), "{1010: 1010, 10100: 10100, 1000000: 1000000, 11111111: 11111111, \ 11111111111111111111111111111111: 11111111111111111111111111111111}"); - t!(format!("{:x}", u32_btree_map), + assert_eq!(format!("{:x}", u32_btree_map), "{a: a, 14: 14, 40: 40, ff: ff, ffffffff: ffffffff}"); - t!(format!("{:X}", u32_btree_map), + assert_eq!(format!("{:X}", u32_btree_map), "{A: A, 14: 14, 40: 40, FF: FF, FFFFFFFF: FFFFFFFF}"); } From cb9221021b409cbad1adb1bf1cc0131dd2e3a502 Mon Sep 17 00:00:00 2001 From: skullzzz Date: Tue, 12 May 2015 23:22:53 -0400 Subject: [PATCH 7/7] remove extra newline in ifmt.rs --- src/test/run-pass/ifmt.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 26f6fc4161822..240b6286c8cfc 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -246,4 +246,3 @@ fn test_order() { foo(), foo(), foo(), a=foo(), b=foo(), c=foo()), "1 2 4 5 3 6".to_string()); } -