From d0c589d5ced5006f72d766af2ccecf699ff76176 Mon Sep 17 00:00:00 2001 From: Tobias Bucher Date: Mon, 23 Feb 2015 23:50:32 +0100 Subject: Hide unnecessary error checking from the user This affects the `set_non_blocking` function which cannot fail for Unix or Windows, given correct parameters. Additionally, the short UDP write error case has been removed as there is no such thing as "short UDP writes", instead, the operating system will error out if the application tries to send a packet larger than the MTU of the network path. --- src/libstd/sys/common/net.rs | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-) (limited to 'src/libstd/sys/common') diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index b5cd42219e1..228362e3d62 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -503,7 +503,7 @@ pub fn connect_timeout(fd: sock_t, #[cfg(windows)] use libc::WSAEWOULDBLOCK as WOULDBLOCK; // Make sure the call to connect() doesn't block - try!(set_nonblocking(fd, true)); + set_nonblocking(fd, true); let ret = match unsafe { libc::connect(fd, addrp, len) } { // If the connection is in progress, then we need to wait for it to @@ -533,7 +533,7 @@ pub fn connect_timeout(fd: sock_t, }; // be sure to turn blocking I/O back on - try!(set_nonblocking(fd, false)); + set_nonblocking(fd, false); return ret; #[cfg(unix)] @@ -626,7 +626,7 @@ pub struct Guard<'a> { #[unsafe_destructor] impl<'a> Drop for Guard<'a> { fn drop(&mut self) { - assert!(set_nonblocking(self.fd, false).is_ok()); + set_nonblocking(self.fd, false); } } @@ -723,7 +723,7 @@ impl TcpStream { fd: self.fd(), guard: self.inner.lock.lock().unwrap(), }; - assert!(set_nonblocking(self.fd(), true).is_ok()); + set_nonblocking(self.fd(), true); ret } @@ -862,7 +862,7 @@ impl UdpSocket { fd: self.fd(), guard: self.inner.lock.lock().unwrap(), }; - assert!(set_nonblocking(self.fd(), true).is_ok()); + set_nonblocking(self.fd(), true); ret } @@ -887,9 +887,7 @@ impl UdpSocket { storagep, &mut addrlen) as libc::c_int })); - sockaddr_to_addr(&storage, addrlen as uint).and_then(|addr| { - Ok((n as uint, addr)) - }) + Ok((n as uint, sockaddr_to_addr(&storage, addrlen as uint).unwrap())) } pub fn send_to(&mut self, buf: &[u8], dst: SocketAddr) -> IoResult<()> { @@ -910,11 +908,8 @@ impl UdpSocket { }; let n = try!(write(fd, self.write_deadline, buf, false, dolock, dowrite)); - if n != buf.len() { - Err(short_write(n, "couldn't send entire packet at once")) - } else { - Ok(()) - } + assert!(n == buf.len(), "UDP packet not completely written."); + Ok(()) } pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { -- cgit 1.4.1-3-g733a5 From 2807a1ce0255ce98415ebe6f65eb589d0f2f894b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Tue, 24 Feb 2015 21:15:45 +0300 Subject: Use arrays instead of vectors in tests --- src/doc/trpl/macros.md | 2 +- src/libcollections/binary_heap.rs | 2 +- src/libcollections/bit.rs | 12 ++-- src/libcollections/btree/map.rs | 4 +- src/libcollections/btree/set.rs | 20 +++---- src/libcollections/enum_set.rs | 22 +++---- src/libcollections/linked_list.rs | 4 +- src/libcollections/macros.rs | 2 +- src/libcollections/slice.rs | 40 ++++++------- src/libcollections/str.rs | 70 +++++++++++------------ src/libcollections/string.rs | 6 +- src/libcollections/vec.rs | 62 ++++++++++---------- src/libcollections/vec_deque.rs | 14 ++--- src/libcollections/vec_map.rs | 6 +- src/libcore/iter.rs | 4 +- src/libcore/option.rs | 2 +- src/libcore/result.rs | 4 +- src/libcoretest/iter.rs | 53 +++++++---------- src/libcoretest/mem.rs | 2 +- src/libcoretest/nonzero.rs | 2 +- src/libcoretest/ptr.rs | 2 +- src/libcoretest/str.rs | 32 +++++------ src/librbml/io.rs | 2 +- src/librustc_driver/test.rs | 10 ++-- src/libserialize/json.rs | 10 ++-- src/libstd/old_io/extensions.rs | 16 +++--- src/libstd/old_io/mem.rs | 18 +++--- src/libstd/old_io/result.rs | 2 +- src/libstd/old_io/util.rs | 20 +++---- src/libstd/sys/common/wtf8.rs | 6 +- src/libsyntax/ext/expand.rs | 6 +- src/libsyntax/ext/mtwt.rs | 24 ++++---- src/libsyntax/util/small_vector.rs | 4 +- src/libterm/terminfo/parm.rs | 6 +- src/test/run-pass/auto-ref-sliceable.rs | 2 +- src/test/run-pass/coerce-reborrow-mut-vec-arg.rs | 2 +- src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs | 2 +- src/test/run-pass/generic-static-methods.rs | 2 +- src/test/run-pass/monad.rs | 12 ++-- src/test/run-pass/trait-generic.rs | 8 +-- src/test/run-pass/unboxed-closures-infer-upvar.rs | 2 +- 41 files changed, 254 insertions(+), 267 deletions(-) (limited to 'src/libstd/sys/common') diff --git a/src/doc/trpl/macros.md b/src/doc/trpl/macros.md index ce6fa3ce949..49da298bb3f 100644 --- a/src/doc/trpl/macros.md +++ b/src/doc/trpl/macros.md @@ -73,7 +73,7 @@ macro_rules! vec { }; } # fn main() { -# assert_eq!(&[1,2,3], &vec![1,2,3]); +# assert_eq!([1,2,3], vec![1,2,3]); # } ``` diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 9f549fd7237..36c76dbad14 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -480,7 +480,7 @@ impl BinaryHeap { /// heap.push(3); /// /// let vec = heap.into_sorted_vec(); - /// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7]); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]); /// ``` pub fn into_sorted_vec(mut self) -> Vec { let mut end = self.len(); diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index f28f9976f0c..61bb204a443 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -640,13 +640,13 @@ impl BitVec { /// let mut bv = BitVec::from_elem(3, true); /// bv.set(1, false); /// - /// assert_eq!(bv.to_bytes(), vec!(0b10100000)); + /// assert_eq!(bv.to_bytes(), [0b10100000]); /// /// let mut bv = BitVec::from_elem(9, false); /// bv.set(2, true); /// bv.set(8, true); /// - /// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); + /// assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]); /// ``` pub fn to_bytes(&self) -> Vec { fn bit(bit_vec: &BitVec, byte: usize, bit: usize) -> u8 { @@ -806,7 +806,7 @@ impl BitVec { /// let mut bv = BitVec::from_bytes(&[0b01001011]); /// bv.grow(2, true); /// assert_eq!(bv.len(), 10); - /// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000)); + /// assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]); /// ``` pub fn grow(&mut self, n: usize, value: bool) { // Note: we just bulk set all the bits in the last word in this fn in multiple places @@ -2285,12 +2285,12 @@ mod tests { fn test_to_bytes() { let mut bv = BitVec::from_elem(3, true); bv.set(1, false); - assert_eq!(bv.to_bytes(), vec!(0b10100000)); + assert_eq!(bv.to_bytes(), [0b10100000]); let mut bv = BitVec::from_elem(9, false); bv.set(2, true); bv.set(8, true); - assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); + assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]); } #[test] @@ -2675,7 +2675,7 @@ mod bit_set_test { let bit_vec: BitSet = usizes.into_iter().collect(); let idxs: Vec<_> = bit_vec.iter().collect(); - assert_eq!(idxs, vec![0, 2, 3]); + assert_eq!(idxs, [0, 2, 3]); let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect(); let real: Vec<_> = range_step(0, 10000, 2).collect(); diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 1b456eec830..6b83253faed 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -1281,7 +1281,7 @@ impl BTreeMap { /// a.insert(2, "b"); /// /// let keys: Vec = a.keys().cloned().collect(); - /// assert_eq!(keys, vec![1,2,]); + /// assert_eq!(keys, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { @@ -1303,7 +1303,7 @@ impl BTreeMap { /// a.insert(2, "b"); /// /// let values: Vec<&str> = a.values().cloned().collect(); - /// assert_eq!(values, vec!["a","b"]); + /// assert_eq!(values, ["a", "b"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn values<'a>(&'a self) -> Values<'a, K, V> { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 929b2f58043..8a668a23dbb 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -121,7 +121,7 @@ impl BTreeSet { /// } /// /// let v: Vec = set.iter().cloned().collect(); - /// assert_eq!(v, vec![1,2,3,4]); + /// assert_eq!(v, [1, 2, 3, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter { @@ -138,7 +138,7 @@ impl BTreeSet { /// let set: BTreeSet = [1, 2, 3, 4].iter().cloned().collect(); /// /// let v: Vec = set.into_iter().collect(); - /// assert_eq!(v, vec![1,2,3,4]); + /// assert_eq!(v, [1, 2, 3, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter { @@ -197,7 +197,7 @@ impl BTreeSet { /// b.insert(3); /// /// let diff: Vec = a.difference(&b).cloned().collect(); - /// assert_eq!(diff, vec![1]); + /// assert_eq!(diff, [1]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn difference<'a>(&'a self, other: &'a BTreeSet) -> Difference<'a, T> { @@ -220,7 +220,7 @@ impl BTreeSet { /// b.insert(3); /// /// let sym_diff: Vec = a.symmetric_difference(&b).cloned().collect(); - /// assert_eq!(sym_diff, vec![1,3]); + /// assert_eq!(sym_diff, [1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet) @@ -244,7 +244,7 @@ impl BTreeSet { /// b.insert(3); /// /// let intersection: Vec = a.intersection(&b).cloned().collect(); - /// assert_eq!(intersection, vec![2]); + /// assert_eq!(intersection, [2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn intersection<'a>(&'a self, other: &'a BTreeSet) @@ -266,7 +266,7 @@ impl BTreeSet { /// b.insert(2); /// /// let union: Vec = a.union(&b).cloned().collect(); - /// assert_eq!(union, vec![1,2]); + /// assert_eq!(union, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn union<'a>(&'a self, other: &'a BTreeSet) -> Union<'a, T> { @@ -534,7 +534,7 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet> for &'a BTreeSet { /// /// let result = &a - &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 2]); + /// assert_eq!(result_vec, [1, 2]); /// ``` fn sub(self, rhs: &BTreeSet) -> BTreeSet { self.difference(rhs).cloned().collect() @@ -557,7 +557,7 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet> for &'a BTreeSet { /// /// let result = &a ^ &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 4]); + /// assert_eq!(result_vec, [1, 4]); /// ``` fn bitxor(self, rhs: &BTreeSet) -> BTreeSet { self.symmetric_difference(rhs).cloned().collect() @@ -580,7 +580,7 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet> for &'a BTreeSet { /// /// let result = &a & &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![2, 3]); + /// assert_eq!(result_vec, [2, 3]); /// ``` fn bitand(self, rhs: &BTreeSet) -> BTreeSet { self.intersection(rhs).cloned().collect() @@ -603,7 +603,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet> for &'a BTreeSet { /// /// let result = &a | &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 2, 3, 4, 5]); + /// assert_eq!(result_vec, [1, 2, 3, 4, 5]); /// ``` fn bitor(self, rhs: &BTreeSet) -> BTreeSet { self.union(rhs).cloned().collect() diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 0c957426060..12c5d7a9cc6 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -428,19 +428,19 @@ mod test { e1.insert(A); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A], elems); + assert_eq!([A], elems); e1.insert(C); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,C], elems); + assert_eq!([A,C], elems); e1.insert(C); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,C], elems); + assert_eq!([A,C], elems); e1.insert(B); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,B,C], elems); + assert_eq!([A,B,C], elems); } /////////////////////////////////////////////////////////////////////////// @@ -458,35 +458,35 @@ mod test { let e_union = e1 | e2; let elems: ::vec::Vec<_> = e_union.iter().collect(); - assert_eq!(vec![A,B,C], elems); + assert_eq!([A,B,C], elems); let e_intersection = e1 & e2; let elems: ::vec::Vec<_> = e_intersection.iter().collect(); - assert_eq!(vec![C], elems); + assert_eq!([C], elems); // Another way to express intersection let e_intersection = e1 - (e1 - e2); let elems: ::vec::Vec<_> = e_intersection.iter().collect(); - assert_eq!(vec![C], elems); + assert_eq!([C], elems); let e_subtract = e1 - e2; let elems: ::vec::Vec<_> = e_subtract.iter().collect(); - assert_eq!(vec![A], elems); + assert_eq!([A], elems); // Bitwise XOR of two sets, aka symmetric difference let e_symmetric_diff = e1 ^ e2; let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); // Another way to express symmetric difference let e_symmetric_diff = (e1 - e2) | (e2 - e1); let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); // Yet another way to express symmetric difference let e_symmetric_diff = (e1 | e2) - (e1 & e2); let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); } #[test] diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index 3c61fc3da90..aa9bd5b0fed 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -777,7 +777,7 @@ impl<'a, A> IterMut<'a, A> { /// } /// { /// let vec: Vec<_> = list.into_iter().collect(); - /// assert_eq!(vec, vec![1, 2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); /// } /// ``` #[inline] @@ -1273,7 +1273,7 @@ mod tests { } check_links(&m); assert_eq!(m.len(), 3 + len * 2); - assert_eq!(m.into_iter().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); + assert_eq!(m.into_iter().collect::>(), [-2,0,1,2,3,4,5,6,7,8,9,0,1]); } #[test] diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index ebcfb8d1cf8..e9764547628 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -26,7 +26,7 @@ /// /// ``` /// let v = vec![1; 3]; -/// assert_eq!(v, vec![1, 1, 1]); +/// assert_eq!(v, [1, 1, 1]); /// ``` /// /// Note that unlike array expressions this syntax supports all elements diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 776b8b3af14..6850e8c0f8e 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1779,10 +1779,10 @@ mod tests { let mut v = vec![1, 2, 3, 4, 5]; let mut e = v.swap_remove(0); assert_eq!(e, 1); - assert_eq!(v, vec![5, 2, 3, 4]); + assert_eq!(v, [5, 2, 3, 4]); e = v.swap_remove(3); assert_eq!(e, 4); - assert_eq!(v, vec![5, 2, 3]); + assert_eq!(v, [5, 2, 3]); } #[test] @@ -1890,7 +1890,7 @@ mod tests { fn test_retain() { let mut v = vec![1, 2, 3, 4, 5]; v.retain(is_odd); - assert_eq!(v, vec![1, 3, 5]); + assert_eq!(v, [1, 3, 5]); } #[test] @@ -2159,45 +2159,45 @@ mod tests { let v: [Vec; 0] = []; let c = v.concat(); assert_eq!(c, []); - let d = [vec![1], vec![2,3]].concat(); - assert_eq!(d, vec![1, 2, 3]); + let d = [vec![1], vec![2, 3]].concat(); + assert_eq!(d, [1, 2, 3]); let v: &[&[_]] = &[&[1], &[2, 3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 3]); let v: &[&[_]] = &[&[1], &[2], &[3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]); } #[test] fn test_connect() { let v: [Vec; 0] = []; - assert_eq!(v.connect(&0), vec![]); - assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]); - assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), []); + assert_eq!([vec![1i], vec![2, 3]].connect(&0), [1, 0, 2, 3]); + assert_eq!([vec![1i], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]); let v: [&[_]; 2] = [&[1], &[2, 3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 3]); let v: [&[_]; 3] = [&[1], &[2], &[3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]); } #[test] fn test_insert() { let mut a = vec![1, 2, 4]; a.insert(2, 3); - assert_eq!(a, vec![1, 2, 3, 4]); + assert_eq!(a, [1, 2, 3, 4]); let mut a = vec![1, 2, 3]; a.insert(0, 0); - assert_eq!(a, vec![0, 1, 2, 3]); + assert_eq!(a, [0, 1, 2, 3]); let mut a = vec![1, 2, 3]; a.insert(3, 4); - assert_eq!(a, vec![1, 2, 3, 4]); + assert_eq!(a, [1, 2, 3, 4]); let mut a = vec![]; a.insert(0, 1); - assert_eq!(a, vec![1]); + assert_eq!(a, [1]); } #[test] @@ -2212,16 +2212,16 @@ mod tests { let mut a = vec![1, 2, 3, 4]; assert_eq!(a.remove(2), 3); - assert_eq!(a, vec![1, 2, 4]); + assert_eq!(a, [1, 2, 4]); assert_eq!(a.remove(2), 4); - assert_eq!(a, vec![1, 2]); + assert_eq!(a, [1, 2]); assert_eq!(a.remove(0), 1); - assert_eq!(a, vec![2]); + assert_eq!(a, [2]); assert_eq!(a.remove(0), 2); - assert_eq!(a, vec![]); + assert_eq!(a, []); } #[test] diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index f3b2e973897..c58cca828d8 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -552,7 +552,7 @@ pub trait StrExt: Index { /// ``` /// let v: Vec = "abc åäö".chars().collect(); /// - /// assert_eq!(v, vec!['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); + /// assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn chars(&self) -> Chars { @@ -600,20 +600,20 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); - /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]); + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); /// /// let v: Vec<&str> = "".split('X').collect(); - /// assert_eq!(v, vec![""]); + /// assert_eq!(v, [""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def", "ghi"]); + /// assert_eq!(v, ["abc", "def", "ghi"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); - /// assert_eq!(v, vec!["lion", "", "tiger", "leopard"]); + /// assert_eq!(v, ["lion", "", "tiger", "leopard"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> { @@ -632,23 +632,23 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<&str> = "Mary had a little lambda".splitn(2, ' ').collect(); - /// assert_eq!(v, vec!["Mary", "had", "a little lambda"]); + /// assert_eq!(v, ["Mary", "had", "a little lambda"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(2, 'X').collect(); - /// assert_eq!(v, vec!["lion", "", "tigerXleopard"]); + /// assert_eq!(v, ["lion", "", "tigerXleopard"]); /// /// let v: Vec<&str> = "abcXdef".splitn(0, 'X').collect(); - /// assert_eq!(v, vec!["abcXdef"]); + /// assert_eq!(v, ["abcXdef"]); /// /// let v: Vec<&str> = "".splitn(1, 'X').collect(); - /// assert_eq!(v, vec![""]); + /// assert_eq!(v, [""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def2ghi"]); + /// assert_eq!(v, ["abc", "def2ghi"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> { @@ -669,17 +669,17 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<&str> = "A.B.".split_terminator('.').collect(); - /// assert_eq!(v, vec!["A", "B"]); + /// assert_eq!(v, ["A", "B"]); /// /// let v: Vec<&str> = "A..B..".split_terminator('.').collect(); - /// assert_eq!(v, vec!["A", "", "B", ""]); + /// assert_eq!(v, ["A", "", "B", ""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def", "ghi"]); + /// assert_eq!(v, ["abc", "def", "ghi"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> { @@ -699,17 +699,17 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(2, ' ').collect(); - /// assert_eq!(v, vec!["lamb", "little", "Mary had a"]); + /// assert_eq!(v, ["lamb", "little", "Mary had a"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect(); - /// assert_eq!(v, vec!["leopard", "tiger", "lionX"]); + /// assert_eq!(v, ["leopard", "tiger", "lionX"]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["ghi", "abc1def"]); + /// assert_eq!(v, ["ghi", "abc1def"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> { @@ -727,13 +727,13 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); - /// assert_eq!(v, vec![(0,3), (6,9), (12,15)]); + /// assert_eq!(v, [(0,3), (6,9), (12,15)]); /// /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); - /// assert_eq!(v, vec![(1,4), (4,7)]); + /// assert_eq!(v, [(1,4), (4,7)]); /// /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); - /// assert_eq!(v, vec![(0, 3)]); // only the first `aba` + /// assert_eq!(v, [(0, 3)]); // only the first `aba` /// ``` #[unstable(feature = "collections", reason = "might have its iterator type changed")] @@ -749,10 +749,10 @@ pub trait StrExt: Index { /// /// ``` /// let v: Vec<&str> = "abcXXXabcYYYabc".split_str("abc").collect(); - /// assert_eq!(v, vec!["", "XXX", "YYY", ""]); + /// assert_eq!(v, ["", "XXX", "YYY", ""]); /// /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); - /// assert_eq!(v, vec!["1", "", "2"]); + /// assert_eq!(v, ["1", "", "2"]); /// ``` #[unstable(feature = "collections")] #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] @@ -770,7 +770,7 @@ pub trait StrExt: Index { /// let four_lines = "foo\nbar\n\nbaz"; /// let v: Vec<&str> = four_lines.lines().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` /// /// Leaving off the trailing character: @@ -779,7 +779,7 @@ pub trait StrExt: Index { /// let four_lines = "foo\nbar\n\nbaz\n"; /// let v: Vec<&str> = four_lines.lines().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn lines(&self) -> Lines { @@ -796,7 +796,7 @@ pub trait StrExt: Index { /// let four_lines = "foo\r\nbar\n\r\nbaz"; /// let v: Vec<&str> = four_lines.lines_any().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` /// /// Leaving off the trailing character: @@ -805,7 +805,7 @@ pub trait StrExt: Index { /// let four_lines = "foo\r\nbar\n\r\nbaz\n"; /// let v: Vec<&str> = four_lines.lines_any().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn lines_any(&self) -> LinesAny { @@ -1441,7 +1441,7 @@ pub trait StrExt: Index { /// let some_words = " Mary had\ta little \n\t lamb"; /// let v: Vec<&str> = some_words.words().collect(); /// - /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]); + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); /// ``` #[unstable(feature = "str_words", reason = "the precise algorithm to use is unclear")] @@ -2400,17 +2400,17 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: Vec<&str> = data.splitn(3, ' ').collect(); - assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect(); - assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); // Unicode let split: Vec<&str> = data.splitn(3, 'ä').collect(); - assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect(); - assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); } #[test] @@ -2418,17 +2418,17 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: Vec<&str> = data.split('\n').collect(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb", ""]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]); let split: Vec<&str> = data.split_terminator('\n').collect(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb"]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]); } #[test] fn test_words() { let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n"; let words: Vec<&str> = data.words().collect(); - assert_eq!(words, vec!["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) + assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) } #[test] @@ -2513,11 +2513,11 @@ mod tests { fn test_lines() { let data = "\nMäry häd ä little lämb\n\nLittle lämb\n"; let lines: Vec<&str> = data.lines().collect(); - assert_eq!(lines, vec!["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n let lines: Vec<&str> = data.lines().collect(); - assert_eq!(lines, vec!["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); } #[test] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 6c2624cd204..e9070cff207 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -120,7 +120,7 @@ impl String { /// let invalid_vec = vec![240, 144, 128]; /// let s = String::from_utf8(invalid_vec).err().unwrap(); /// assert_eq!(s.utf8_error(), Utf8Error::TooShort); - /// assert_eq!(s.into_bytes(), vec![240, 144, 128]); + /// assert_eq!(s.into_bytes(), [240, 144, 128]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -340,7 +340,7 @@ impl String { /// ``` /// let s = String::from_str("hello"); /// let bytes = s.into_bytes(); - /// assert_eq!(bytes, vec![104, 101, 108, 108, 111]); + /// assert_eq!(bytes, [104, 101, 108, 108, 111]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -619,7 +619,7 @@ impl String { /// let mut s = String::from_str("hello"); /// unsafe { /// let vec = s.as_mut_vec(); - /// assert!(vec == &mut vec![104, 101, 108, 108, 111]); + /// assert!(vec == &[104, 101, 108, 108, 111]); /// vec.reverse(); /// } /// assert_eq!(s.as_slice(), "olleh"); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 3f5f9288916..c446618649d 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -93,7 +93,7 @@ use borrow::{Cow, IntoCow}; /// for x in vec.iter() { /// println!("{}", x); /// } -/// assert_eq!(vec, vec![7, 1, 2, 3]); +/// assert_eq!(vec, [7, 1, 2, 3]); /// ``` /// /// The `vec!` macro is provided to make initialization more convenient: @@ -101,7 +101,7 @@ use borrow::{Cow, IntoCow}; /// ``` /// let mut vec = vec![1, 2, 3]; /// vec.push(4); -/// assert_eq!(vec, vec![1, 2, 3, 4]); +/// assert_eq!(vec, [1, 2, 3, 4]); /// ``` /// /// Use a `Vec` as an efficient stack: @@ -242,7 +242,7 @@ impl Vec { /// /// // Put everything back together into a Vec /// let rebuilt = Vec::from_raw_parts(p, len, cap); - /// assert_eq!(rebuilt, vec![4, 5, 6]); + /// assert_eq!(rebuilt, [4, 5, 6]); /// } /// } /// ``` @@ -404,7 +404,7 @@ impl Vec { /// ``` /// let mut vec = vec![1, 2, 3, 4]; /// vec.truncate(2); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn truncate(&mut self, len: usize) { @@ -505,10 +505,10 @@ impl Vec { /// let mut v = vec!["foo", "bar", "baz", "qux"]; /// /// assert_eq!(v.swap_remove(1), "bar"); - /// assert_eq!(v, vec!["foo", "qux", "baz"]); + /// assert_eq!(v, ["foo", "qux", "baz"]); /// /// assert_eq!(v.swap_remove(0), "foo"); - /// assert_eq!(v, vec!["baz", "qux"]); + /// assert_eq!(v, ["baz", "qux"]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -531,9 +531,9 @@ impl Vec { /// ``` /// let mut vec = vec![1, 2, 3]; /// vec.insert(1, 4); - /// assert_eq!(vec, vec![1, 4, 2, 3]); + /// assert_eq!(vec, [1, 4, 2, 3]); /// vec.insert(4, 5); - /// assert_eq!(vec, vec![1, 4, 2, 3, 5]); + /// assert_eq!(vec, [1, 4, 2, 3, 5]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(&mut self, index: usize, element: T) { @@ -569,7 +569,7 @@ impl Vec { /// ``` /// let mut v = vec![1, 2, 3]; /// assert_eq!(v.remove(1), 2); - /// assert_eq!(v, vec![1, 3]); + /// assert_eq!(v, [1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn remove(&mut self, index: usize) -> T { @@ -603,7 +603,7 @@ impl Vec { /// ``` /// let mut vec = vec![1, 2, 3, 4]; /// vec.retain(|&x| x%2 == 0); - /// assert_eq!(vec, vec![2, 4]); + /// assert_eq!(vec, [2, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn retain(&mut self, mut f: F) where F: FnMut(&T) -> bool { @@ -636,7 +636,7 @@ impl Vec { /// ```rust /// let mut vec = vec!(1, 2); /// vec.push(3); - /// assert_eq!(vec, vec!(1, 2, 3)); + /// assert_eq!(vec, [1, 2, 3]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -674,7 +674,7 @@ impl Vec { /// ```rust /// let mut vec = vec![1, 2, 3]; /// assert_eq!(vec.pop(), Some(3)); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -701,8 +701,8 @@ impl Vec { /// let mut vec = vec![1, 2, 3]; /// let mut vec2 = vec![4, 5, 6]; /// vec.append(&mut vec2); - /// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6]); - /// assert_eq!(vec2, vec![]); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + /// assert_eq!(vec2, []); /// ``` #[inline] #[unstable(feature = "collections", @@ -1019,8 +1019,8 @@ impl Vec { /// ``` /// let mut vec = vec![1,2,3]; /// let vec2 = vec.split_off(1); - /// assert_eq!(vec, vec![1]); - /// assert_eq!(vec2, vec![2, 3]); + /// assert_eq!(vec, [1]); + /// assert_eq!(vec2, [2, 3]); /// ``` #[inline] #[unstable(feature = "collections", @@ -1057,11 +1057,11 @@ impl Vec { /// ``` /// let mut vec = vec!["hello"]; /// vec.resize(3, "world"); - /// assert_eq!(vec, vec!["hello", "world", "world"]); + /// assert_eq!(vec, ["hello", "world", "world"]); /// /// let mut vec = vec![1, 2, 3, 4]; /// vec.resize(2, 0); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification; waiting for dust to settle")] @@ -1085,7 +1085,7 @@ impl Vec { /// ``` /// let mut vec = vec![1]; /// vec.push_all(&[2, 3, 4]); - /// assert_eq!(vec, vec![1, 2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); /// ``` #[inline] #[unstable(feature = "collections", @@ -1121,7 +1121,7 @@ impl Vec { /// /// vec.dedup(); /// - /// assert_eq!(vec, vec![1, 2, 3, 2]); + /// assert_eq!(vec, [1, 2, 3, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn dedup(&mut self) { @@ -2105,7 +2105,7 @@ mod tests { } } - assert!(values == vec![2, 3, 5, 6, 7]); + assert_eq!(values, [2, 3, 5, 6, 7]); } #[test] @@ -2147,7 +2147,7 @@ mod tests { fn test_retain() { let mut vec = vec![1, 2, 3, 4]; vec.retain(|&x| x % 2 == 0); - assert!(vec == vec![2, 4]); + assert_eq!(vec, [2, 4]); } #[test] @@ -2207,13 +2207,13 @@ mod tests { let a = [1, 2, 3]; let ptr = a.as_ptr(); let b = Vec::from_raw_buf(ptr, 3); - assert_eq!(b, vec![1, 2, 3]); + assert_eq!(b, [1, 2, 3]); // Test on-heap copy-from-buf. let c = vec![1, 2, 3, 4, 5]; let ptr = c.as_ptr(); let d = Vec::from_raw_buf(ptr, 5); - assert_eq!(d, vec![1, 2, 3, 4, 5]); + assert_eq!(d, [1, 2, 3, 4, 5]); } } @@ -2375,7 +2375,7 @@ mod tests { for i in vec { vec2.push(i); } - assert!(vec2 == vec![1, 2, 3]); + assert_eq!(vec2, [1, 2, 3]); } #[test] @@ -2385,7 +2385,7 @@ mod tests { for i in vec.into_iter().rev() { vec2.push(i); } - assert!(vec2 == vec![3, 2, 1]); + assert_eq!(vec2, [3, 2, 1]); } #[test] @@ -2395,7 +2395,7 @@ mod tests { for i in vec { vec2.push(i); } - assert!(vec2 == vec![(), (), ()]); + assert_eq!(vec2, [(), (), ()]); } #[test] @@ -2443,16 +2443,16 @@ mod tests { let mut vec = vec![1, 2, 3]; let mut vec2 = vec![4, 5, 6]; vec.append(&mut vec2); - assert_eq!(vec, vec![1, 2, 3, 4, 5, 6]); - assert_eq!(vec2, vec![]); + assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + assert_eq!(vec2, []); } #[test] fn test_split_off() { let mut vec = vec![1, 2, 3, 4, 5, 6]; let vec2 = vec.split_off(4); - assert_eq!(vec, vec![1, 2, 3, 4]); - assert_eq!(vec2, vec![5, 6]); + assert_eq!(vec, [1, 2, 3, 4]); + assert_eq!(vec2, [5, 6]); } #[bench] diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index f65e644fa52..9476b98eb82 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -2105,7 +2105,7 @@ mod tests { let mut d: VecDeque<_> = (0..5).collect(); d.pop_front(); d.swap(0, 3); - assert_eq!(d.iter().cloned().collect::>(), vec!(4, 2, 3, 1)); + assert_eq!(d.iter().cloned().collect::>(), [4, 2, 3, 1]); } #[test] @@ -2868,17 +2868,17 @@ mod tests { // normal append a.append(&mut b); - assert_eq!(a.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(b.iter().cloned().collect(), vec![]); + assert_eq!(a.iter().cloned().collect(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect(), []); // append nothing to something a.append(&mut b); - assert_eq!(a.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(b.iter().cloned().collect(), vec![]); + assert_eq!(a.iter().cloned().collect(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect(), []); // append something to nothing b.append(&mut a); - assert_eq!(b.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(a.iter().cloned().collect(), vec![]); + assert_eq!(b.iter().cloned().collect(), [1, 2, 3, 4, 5, 6]); + assert_eq!(a.iter().cloned().collect(), []); } } diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index d92249379fa..1c497c86dfd 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -308,7 +308,7 @@ impl VecMap { /// /// let vec: Vec<(usize, &str)> = map.into_iter().collect(); /// - /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + /// assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter { @@ -425,7 +425,7 @@ impl VecMap { /// /// let vec: Vec<(usize, &str)> = map.drain().collect(); /// - /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + /// assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] @@ -1226,7 +1226,7 @@ mod test_map { let vec: Vec<_> = map.drain().collect(); - assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); assert_eq!(map.len(), 0); } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 09089f2d04c..6d8e04d97dd 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -582,8 +582,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` /// let vec = vec![1, 2, 3, 4]; /// let (even, odd): (Vec<_>, Vec<_>) = vec.into_iter().partition(|&n| n % 2 == 0); - /// assert_eq!(even, vec![2, 4]); - /// assert_eq!(odd, vec![1, 3]); + /// assert_eq!(even, [2, 4]); + /// assert_eq!(odd, [1, 3]); /// ``` #[unstable(feature = "core", reason = "recently added as part of collections reform")] diff --git a/src/libcore/option.rs b/src/libcore/option.rs index abfef72a5db..1ecbd8fae8c 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -556,7 +556,7 @@ impl Option { /// ``` /// let x = Some("string"); /// let v: Vec<&str> = x.into_iter().collect(); - /// assert_eq!(v, vec!["string"]); + /// assert_eq!(v, ["string"]); /// /// let x = None; /// let v: Vec<&str> = x.into_iter().collect(); diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 23e936a75d7..bca73782491 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -548,11 +548,11 @@ impl Result { /// ``` /// let x: Result = Ok(5); /// let v: Vec = x.into_iter().collect(); - /// assert_eq!(v, vec![5]); + /// assert_eq!(v, [5]); /// /// let x: Result = Err("nothing!"); /// let v: Vec = x.into_iter().collect(); - /// assert_eq!(v, vec![]); + /// assert_eq!(v, []); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 6cbc7bf1bbc..8a27400389f 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -74,7 +74,7 @@ fn test_multi_iter() { fn test_counter_from_iter() { let it = count(0, 5).take(10); let xs: Vec = FromIterator::from_iter(it); - assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); + assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); } #[test] @@ -104,7 +104,7 @@ fn test_iterator_chain() { fn test_filter_map() { let it = count(0, 1).take(10) .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); - assert!(it.collect::>() == vec![0*0, 2*2, 4*4, 6*6, 8*8]); + assert_eq!(it.collect::>(), [0*0, 2*2, 4*4, 6*6, 8*8]); } #[test] @@ -730,12 +730,12 @@ fn test_random_access_cycle() { #[test] fn test_double_ended_range() { - assert!((11..14).rev().collect::>() == vec![13, 12, 11]); + assert_eq!((11..14).rev().collect::>(), [13, 12, 11]); for _ in (10..0).rev() { panic!("unreachable"); } - assert!((11..14).rev().collect::>() == vec![13, 12, 11]); + assert_eq!((11..14).rev().collect::>(), [13, 12, 11]); for _ in (10..0).rev() { panic!("unreachable"); } @@ -743,10 +743,9 @@ fn test_double_ended_range() { #[test] fn test_range() { - assert!((0..5).collect::>() == vec![0, 1, 2, 3, 4]); - assert!((-10..-1).collect::>() == - vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]); - assert!((0..5).rev().collect::>() == vec![4, 3, 2, 1, 0]); + assert_eq!((0..5).collect::>(), [0, 1, 2, 3, 4]); + assert_eq!((-10..-1).collect::>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]); + assert_eq!((0..5).rev().collect::>(), [4, 3, 2, 1, 0]); assert_eq!((200..-5).count(), 0); assert_eq!((200..-5).rev().count(), 0); assert_eq!((200..200).count(), 0); @@ -767,38 +766,28 @@ fn test_range_inclusive() { vec![5, 4, 3, 2, 1, 0]); assert_eq!(range_inclusive(200, -5).count(), 0); assert_eq!(range_inclusive(200, -5).rev().count(), 0); - assert!(range_inclusive(200, 200).collect::>() == vec![200]); - assert!(range_inclusive(200, 200).rev().collect::>() == vec![200]); + assert_eq!(range_inclusive(200, 200).collect::>(), [200]); + assert_eq!(range_inclusive(200, 200).rev().collect::>(), [200]); } #[test] fn test_range_step() { - assert!(range_step(0, 20, 5).collect::>() == - vec![0, 5, 10, 15]); - assert!(range_step(20, 0, -5).collect::>() == - vec![20, 15, 10, 5]); - assert!(range_step(20, 0, -6).collect::>() == - vec![20, 14, 8, 2]); - assert!(range_step(200u8, 255, 50).collect::>() == - vec![200u8, 250]); - assert!(range_step(200, -5, 1).collect::>() == vec![]); - assert!(range_step(200, 200, 1).collect::>() == vec![]); + assert_eq!(range_step(0, 20, 5).collect::>(), [0, 5, 10, 15]); + assert_eq!(range_step(20, 0, -5).collect::>(), [20, 15, 10, 5]); + assert_eq!(range_step(20, 0, -6).collect::>(), [20, 14, 8, 2]); + assert_eq!(range_step(200u8, 255, 50).collect::>(), [200u8, 250]); + assert_eq!(range_step(200i, -5, 1).collect::>(), []); + assert_eq!(range_step(200i, 200, 1).collect::>(), []); } #[test] fn test_range_step_inclusive() { - assert!(range_step_inclusive(0, 20, 5).collect::>() == - vec![0, 5, 10, 15, 20]); - assert!(range_step_inclusive(20, 0, -5).collect::>() == - vec![20, 15, 10, 5, 0]); - assert!(range_step_inclusive(20, 0, -6).collect::>() == - vec![20, 14, 8, 2]); - assert!(range_step_inclusive(200u8, 255, 50).collect::>() == - vec![200u8, 250]); - assert!(range_step_inclusive(200, -5, 1).collect::>() == - vec![]); - assert!(range_step_inclusive(200, 200, 1).collect::>() == - vec![200]); + assert_eq!(range_step_inclusive(0, 20, 5).collect::>(), [0, 5, 10, 15, 20]); + assert_eq!(range_step_inclusive(20, 0, -5).collect::>(), [20, 15, 10, 5, 0]); + assert_eq!(range_step_inclusive(20, 0, -6).collect::>(), [20, 14, 8, 2]); + assert_eq!(range_step_inclusive(200u8, 255, 50).collect::>(), [200u8, 250]); + assert_eq!(range_step_inclusive(200, -5, 1).collect::>(), []); + assert_eq!(range_step_inclusive(200, 200, 1).collect::>(), [200]); } #[test] diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs index 5aeb330b78b..73000670c61 100644 --- a/src/libcoretest/mem.rs +++ b/src/libcoretest/mem.rs @@ -103,7 +103,7 @@ fn test_transmute() { } unsafe { - assert!(vec![76u8] == transmute::<_, Vec>("L".to_string())); + assert_eq!([76u8], transmute::<_, Vec>("L".to_string())); } } diff --git a/src/libcoretest/nonzero.rs b/src/libcoretest/nonzero.rs index be4c83d23e8..f60570eaaf4 100644 --- a/src/libcoretest/nonzero.rs +++ b/src/libcoretest/nonzero.rs @@ -54,7 +54,7 @@ fn test_match_option_empty_vec() { fn test_match_option_vec() { let a = Some(vec![1, 2, 3, 4]); match a { - Some(v) => assert_eq!(v, vec![1, 2, 3, 4]), + Some(v) => assert_eq!(v, [1, 2, 3, 4]), None => panic!("unexpected None while matching on Some(vec![1, 2, 3, 4])") } } diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index 57456bfb1a7..c8a54ef59ab 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -156,7 +156,7 @@ fn test_ptr_subtraction() { m_ptr = m_ptr.offset(-1); } - assert!(xs_mut == vec![0,2,4,6,8,10,12,14,16,18]); + assert_eq!(xs_mut, [0,2,4,6,8,10,12,14,16,18]); } } diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index beb746d25b6..019f935911f 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -22,7 +22,7 @@ fn test_pattern_deref_forward() { fn test_empty_match_indices() { let data = "aä中!"; let vec: Vec<_> = data.match_indices("").collect(); - assert_eq!(vec, vec![(0, 0), (1, 1), (3, 3), (6, 6), (7, 7)]); + assert_eq!(vec, [(0, 0), (1, 1), (3, 3), (6, 6), (7, 7)]); } #[test] @@ -69,20 +69,20 @@ fn test_rsplitn_char_iterator() { let mut split: Vec<&str> = data.rsplitn(3, ' ').collect(); split.reverse(); - assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect(); split.reverse(); - assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); // Unicode let mut split: Vec<&str> = data.rsplitn(3, 'ä').collect(); split.reverse(); - assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect(); split.reverse(); - assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -90,33 +90,33 @@ fn test_split_char_iterator() { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: Vec<&str> = data.split(' ').collect(); - assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!( split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let mut rsplit: Vec<&str> = data.split(' ').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let split: Vec<&str> = data.split(|c: char| c == ' ').collect(); - assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!( split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); // Unicode let split: Vec<&str> = data.split('ä').collect(); - assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!( split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let mut rsplit: Vec<&str> = data.split('ä').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let split: Vec<&str> = data.split(|c: char| c == 'ä').collect(); - assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!( split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -125,18 +125,18 @@ fn test_rev_split_char_iterator_no_trailing() { let mut split: Vec<&str> = data.split('\n').rev().collect(); split.reverse(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb", ""]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]); let mut split: Vec<&str> = data.split_terminator('\n').rev().collect(); split.reverse(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb"]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]); } #[test] fn test_utf16_code_units() { use unicode::str::Utf16Encoder; assert_eq!(Utf16Encoder::new(vec!['é', '\u{1F4A9}'].into_iter()).collect::>(), - vec![0xE9, 0xD83D, 0xDCA9]) + [0xE9, 0xD83D, 0xDCA9]) } #[test] diff --git a/src/librbml/io.rs b/src/librbml/io.rs index 230fda11ab5..c52465a8899 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -45,7 +45,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult /// let mut w = SeekableMemWriter::new(); /// w.write(&[0, 1, 2]); /// -/// assert_eq!(w.unwrap(), vec!(0, 1, 2)); +/// assert_eq!(w.unwrap(), [0, 1, 2]); /// ``` pub struct SeekableMemWriter { buf: Vec, diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index cdcc9850e42..d9cedc48298 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -806,11 +806,11 @@ fn walk_ty() { let tup2_ty = ty::mk_tup(tcx, vec!(tup1_ty, tup1_ty, uint_ty)); let uniq_ty = ty::mk_uniq(tcx, tup2_ty); let walked: Vec<_> = uniq_ty.walk().collect(); - assert_eq!(vec!(uniq_ty, - tup2_ty, - tup1_ty, int_ty, uint_ty, int_ty, uint_ty, - tup1_ty, int_ty, uint_ty, int_ty, uint_ty, - uint_ty), + assert_eq!([uniq_ty, + tup2_ty, + tup1_ty, int_ty, uint_ty, int_ty, uint_ty, + tup1_ty, int_ty, uint_ty, int_ty, uint_ty, + uint_ty], walked); }) } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index a0f42815b43..05d4e0f59fe 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -3074,19 +3074,19 @@ mod tests { #[test] fn test_decode_array() { let v: Vec<()> = super::decode("[]").unwrap(); - assert_eq!(v, vec![]); + assert_eq!(v, []); let v: Vec<()> = super::decode("[null]").unwrap(); - assert_eq!(v, vec![()]); + assert_eq!(v, [()]); let v: Vec = super::decode("[true]").unwrap(); - assert_eq!(v, vec![true]); + assert_eq!(v, [true]); let v: Vec = super::decode("[3, 1]").unwrap(); - assert_eq!(v, vec![3, 1]); + assert_eq!(v, [3, 1]); let v: Vec> = super::decode("[[3], [1, 2]]").unwrap(); - assert_eq!(v, vec![vec![3], vec![1, 2]]); + assert_eq!(v, [vec![3], vec![1, 2]]); } #[test] diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs index c2a6c515acc..8bd19f063f0 100644 --- a/src/libstd/old_io/extensions.rs +++ b/src/libstd/old_io/extensions.rs @@ -328,7 +328,7 @@ mod test { fn read_bytes() { let mut reader = MemReader::new(vec!(10, 11, 12, 13)); let bytes = reader.read_exact(4).unwrap(); - assert!(bytes == vec!(10, 11, 12, 13)); + assert_eq!(bytes, [10, 11, 12, 13]); } #[test] @@ -337,7 +337,7 @@ mod test { count: 0, }; let bytes = reader.read_exact(4).unwrap(); - assert!(bytes == vec!(10, 11, 12, 13)); + assert_eq!(bytes, [10, 11, 12, 13]); } #[test] @@ -351,7 +351,7 @@ mod test { let mut reader = MemReader::new(vec![10, 11, 12, 13]); let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_ok()); - assert!(buf == vec![8, 9, 10, 11, 12, 13]); + assert_eq!(buf, [8, 9, 10, 11, 12, 13]); } #[test] @@ -361,7 +361,7 @@ mod test { }; let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_ok()); - assert!(buf == vec![8, 9, 10, 11, 12, 13]); + assert_eq!(buf, [8, 9, 10, 11, 12, 13]); } #[test] @@ -369,7 +369,7 @@ mod test { let mut reader = MemReader::new(vec![10, 11]); let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_err()); - assert!(buf == vec![8, 9, 10, 11]); + assert_eq!(buf, [8, 9, 10, 11]); } #[test] @@ -379,7 +379,7 @@ mod test { }; let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_err()); - assert!(buf == vec![8, 9, 10]); + assert_eq!(buf, [8, 9, 10]); } #[test] @@ -388,7 +388,7 @@ mod test { count: 0, }; let buf = reader.read_to_end().unwrap(); - assert!(buf == vec!(10, 11, 12, 13)); + assert_eq!(buf, [10, 11, 12, 13]); } #[test] @@ -398,7 +398,7 @@ mod test { count: 0, }; let buf = reader.read_to_end().unwrap(); - assert!(buf == vec!(10, 11)); + assert_eq!(buf, [10, 11]); } #[test] diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs index 1fd527014a3..c08a2c1f477 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -60,7 +60,7 @@ impl Writer for Vec { /// let mut w = MemWriter::new(); /// w.write(&[0, 1, 2]); /// -/// assert_eq!(w.into_inner(), vec!(0, 1, 2)); +/// assert_eq!(w.into_inner(), [0, 1, 2]); /// ``` #[unstable(feature = "io")] #[deprecated(since = "1.0.0", @@ -118,7 +118,7 @@ impl Writer for MemWriter { /// /// let mut r = MemReader::new(vec!(0, 1, 2)); /// -/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2)); +/// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]); /// ``` pub struct MemReader { buf: Vec, @@ -321,7 +321,7 @@ impl<'a> Seek for BufWriter<'a> { /// let buf = [0, 1, 2, 3]; /// let mut r = BufReader::new(&buf); /// -/// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]); +/// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2, 3]); /// ``` pub struct BufReader<'a> { buf: &'a [u8], @@ -504,8 +504,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7)); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } @@ -530,8 +530,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = &mut &*in_buf; - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } @@ -557,8 +557,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = BufReader::new(&in_buf); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } diff --git a/src/libstd/old_io/result.rs b/src/libstd/old_io/result.rs index f42cb6ce8c9..cdf2bae1cba 100644 --- a/src/libstd/old_io/result.rs +++ b/src/libstd/old_io/result.rs @@ -87,7 +87,7 @@ mod test { let mut writer: old_io::IoResult> = Ok(Vec::new()); writer.write_all(&[0, 1, 2]).unwrap(); writer.flush().unwrap(); - assert_eq!(writer.unwrap(), vec!(0, 1, 2)); + assert_eq!(writer.unwrap(), [0, 1, 2]); } #[test] diff --git a/src/libstd/old_io/util.rs b/src/libstd/old_io/util.rs index 5ae239014d1..8e49335ed54 100644 --- a/src/libstd/old_io/util.rs +++ b/src/libstd/old_io/util.rs @@ -284,7 +284,7 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 4); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2], r.read_to_end().unwrap()); } } @@ -293,9 +293,9 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 2); - assert_eq!(vec!(0, 1), r.read_to_end().unwrap()); + assert_eq!([0, 1], r.read_to_end().unwrap()); } - assert_eq!(vec!(2), r.read_to_end().unwrap()); + assert_eq!([2], r.read_to_end().unwrap()); } #[test] @@ -305,7 +305,7 @@ mod test { assert_eq!(3, r.limit()); assert_eq!(0, r.read_byte().unwrap()); assert_eq!(2, r.limit()); - assert_eq!(vec!(1, 2), r.read_to_end().unwrap()); + assert_eq!([1, 2], r.read_to_end().unwrap()); assert_eq!(0, r.limit()); } @@ -314,7 +314,7 @@ mod test { let mut r = MemReader::new(vec![0, 1, 2, 3, 4, 5]); let mut r = LimitReader::new(r.by_ref(), 1); r.consume(2); - assert_eq!(vec![], r.read_to_end().unwrap()); + assert_eq!([], r.read_to_end().unwrap()); } #[test] @@ -330,7 +330,7 @@ mod test { let mut s = ZeroReader; let mut buf = vec![1, 2, 3]; assert_eq!(s.read(&mut buf), Ok(3)); - assert_eq!(vec![0, 0, 0], buf); + assert_eq!([0, 0, 0], buf); } #[test] @@ -373,16 +373,16 @@ mod test { let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()), MemReader::new(vec!(2, 3))); let mut r = ChainedReader::new(rs.into_iter()); - assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2, 3], r.read_to_end().unwrap()); } #[test] fn test_tee_reader() { let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)), Vec::new()); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2], r.read_to_end().unwrap()); let (_, w) = r.into_inner(); - assert_eq!(vec!(0, 1, 2), w); + assert_eq!([0, 1, 2], w); } #[test] @@ -390,7 +390,7 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2, 3, 4)); let mut w = Vec::new(); copy(&mut r, &mut w).unwrap(); - assert_eq!(vec!(0, 1, 2, 3, 4), w); + assert_eq!([0, 1, 2, 3, 4], w); } #[test] diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 9119a3c60d8..fb9d6fef1fa 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -1202,11 +1202,11 @@ mod tests { string.code_points().map(|c| c.to_char()).collect::>() } let mut string = Wtf8Buf::from_str("é "); - assert_eq!(cp(&string), vec![Some('é'), Some(' ')]); + assert_eq!(cp(&string), [Some('é'), Some(' ')]); string.push(c(0xD83D)); - assert_eq!(cp(&string), vec![Some('é'), Some(' '), None]); + assert_eq!(cp(&string), [Some('é'), Some(' '), None]); string.push(c(0xDCA9)); - assert_eq!(cp(&string), vec![Some('é'), Some(' '), Some('💩')]); + assert_eq!(cp(&string), [Some('é'), Some(' '), Some('💩')]); } #[test] diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index bc239d0c7c2..91bfe6f32dc 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -2028,7 +2028,7 @@ foo_module!(); let renamed_crate = renamer.fold_crate(the_crate); let idents = crate_idents(&renamed_crate); let resolved : Vec = idents.iter().map(|id| mtwt::resolve(*id)).collect(); - assert_eq!(resolved,vec!(f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16))); + assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16)]); } // test the PatIdentRenamer; only PatIdents get renamed @@ -2044,8 +2044,6 @@ foo_module!(); let idents = crate_idents(&renamed_crate); let resolved : Vec = idents.iter().map(|id| mtwt::resolve(*id)).collect(); let x_name = x_ident.name; - assert_eq!(resolved,vec!(f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name)); + assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name]); } - - } diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index b6563d77b88..72431d8e6aa 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -288,19 +288,19 @@ mod tests { fn xorpush_test () { let mut s = Vec::new(); xor_push(&mut s, 14); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); xor_push(&mut s, 14); - assert_eq!(s.clone(), Vec::new()); + assert_eq!(s.clone(), []); xor_push(&mut s, 14); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); xor_push(&mut s, 15); - assert_eq!(s.clone(), vec!(14, 15)); + assert_eq!(s.clone(), [14, 15]); xor_push(&mut s, 16); - assert_eq!(s.clone(), vec!(14, 15, 16)); + assert_eq!(s.clone(), [14, 15, 16]); xor_push(&mut s, 16); - assert_eq!(s.clone(), vec!(14, 15)); + assert_eq!(s.clone(), [14, 15]); xor_push(&mut s, 15); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); } fn id(n: u32, s: SyntaxContext) -> Ident { @@ -389,13 +389,13 @@ mod tests { assert_eq!(marksof_internal (EMPTY_CTXT,stopname,&t),Vec::new()); // FIXME #5074: ANF'd to dodge nested calls { let ans = unfold_marks(vec!(4,98),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans,stopname,&t),vec!(4,98));} + assert_eq! (marksof_internal (ans,stopname,&t), [4, 98]);} // does xoring work? { let ans = unfold_marks(vec!(5,5,16),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans,stopname,&t), vec!(16));} + assert_eq! (marksof_internal (ans,stopname,&t), [16]);} // does nested xoring work? { let ans = unfold_marks(vec!(5,10,10,5,16),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname,&t), vec!(16));} + assert_eq! (marksof_internal (ans, stopname,&t), [16]);} // rename where stop doesn't match: { let chain = vec!(M(9), R(id(name1.usize() as u32, @@ -403,7 +403,7 @@ mod tests { Name(100101102)), M(14)); let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname, &t), vec!(9,14));} + assert_eq! (marksof_internal (ans, stopname, &t), [9, 14]);} // rename where stop does match { let name1sc = apply_mark_internal(4, EMPTY_CTXT, &mut t); let chain = vec!(M(9), @@ -411,7 +411,7 @@ mod tests { stopname), M(14)); let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname, &t), vec!(9)); } + assert_eq! (marksof_internal (ans, stopname, &t), [9]); } } diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index 0a39d380904..90df23882a1 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -229,10 +229,10 @@ mod test { assert_eq!(Vec::new(), v); let v = SmallVector::one(1); - assert_eq!(vec![1], v.into_iter().collect::>()); + assert_eq!([1], v.into_iter().collect::>()); let v = SmallVector::many(vec![1, 2, 3]); - assert_eq!(vec!(1, 2, 3), v.into_iter().collect::>()); + assert_eq!([1, 2, 3], v.into_iter().collect::>()); } #[test] diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index 0b577f8de74..112525fcce9 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -652,15 +652,15 @@ mod test { let s = format!("%{{1}}%{{2}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[0])); + assert_eq!(res.unwrap(), [b'0' + bs[0]]); let s = format!("%{{1}}%{{1}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[1])); + assert_eq!(res.unwrap(), [b'0' + bs[1]]); let s = format!("%{{2}}%{{1}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[2])); + assert_eq!(res.unwrap(), [b'0' + bs[2]]); } } diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index 652f21c2ae3..d2e9bc2efe7 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -23,5 +23,5 @@ pub fn main() { let mut v = vec!(1); v.push_val(2); v.push_val(3); - assert_eq!(v, vec!(1, 2, 3)); + assert_eq!(v, [1, 2, 3]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index f87f2e07c9d..2473b4b674e 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -22,5 +22,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = vec!(1, 2, 3, 100); bar(&mut the_vec); - assert_eq!(the_vec, vec!(100, 3, 2, 1)); + assert_eq!(the_vec, [100, 3, 2, 1]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index 4f97e6a2081..ea09bb3904d 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -18,5 +18,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = vec!(1, 2, 3, 100); bar(&mut the_vec); - assert_eq!(the_vec, vec!(100, 3, 2, 1)); + assert_eq!(the_vec, [100, 3, 2, 1]); } diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs index 7f84efcdd5d..010f54dd559 100644 --- a/src/test/run-pass/generic-static-methods.rs +++ b/src/test/run-pass/generic-static-methods.rs @@ -24,5 +24,5 @@ impl vec_utils for Vec { } pub fn main() { - assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), vec!(2,3,4)); + assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), [2,3,4]); } diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 457c0a35fd7..0d563f1a714 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -44,11 +44,11 @@ fn transform(x: Option) -> Option { pub fn main() { assert_eq!(transform(Some(10)), Some("11".to_string())); assert_eq!(transform(None), None); - assert!((vec!("hi".to_string())) + assert_eq!((vec!("hi".to_string())) .bind(|x| vec!(x.clone(), format!("{}!", x)) ) - .bind(|x| vec!(x.clone(), format!("{}?", x)) ) == - vec!("hi".to_string(), - "hi?".to_string(), - "hi!".to_string(), - "hi!?".to_string())); + .bind(|x| vec!(x.clone(), format!("{}?", x)) ), + ["hi".to_string(), + "hi?".to_string(), + "hi!".to_string(), + "hi!?".to_string()]); } diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index 5f4b18df6e1..0dedf621a4f 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -44,9 +44,9 @@ fn bar>(x: T) -> Vec { } pub fn main() { - assert_eq!(foo(vec!(1)), vec!("hi".to_string())); - assert_eq!(bar:: >(vec!(4, 5)), vec!("4".to_string(), "5".to_string())); + assert_eq!(foo(vec!(1)), ["hi".to_string()]); + assert_eq!(bar:: >(vec!(4, 5)), ["4".to_string(), "5".to_string()]); assert_eq!(bar:: >(vec!("x".to_string(), "y".to_string())), - vec!("x".to_string(), "y".to_string())); - assert_eq!(bar::<(), Vec<()>>(vec!(())), vec!("()".to_string())); + ["x".to_string(), "y".to_string()]); + assert_eq!(bar::<(), Vec<()>>(vec!(())), ["()".to_string()]); } diff --git a/src/test/run-pass/unboxed-closures-infer-upvar.rs b/src/test/run-pass/unboxed-closures-infer-upvar.rs index 087ef5dcf05..1401fe7470b 100644 --- a/src/test/run-pass/unboxed-closures-infer-upvar.rs +++ b/src/test/run-pass/unboxed-closures-infer-upvar.rs @@ -18,5 +18,5 @@ fn f(mut f: F) { fn main() { let mut v: Vec<_> = vec![]; f(|| v.push(0)); - assert_eq!(v, vec![0]); + assert_eq!(v, [0]); } -- cgit 1.4.1-3-g733a5