From 5cf126ae2f6af1cdac901f6995e3c2bab35e587f Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 10 Mar 2015 17:59:23 -0700
Subject: [PATCH] std: Remove #[old_orphan_check] from PartialEq
This is a deprecated attribute that is slated for removal, and it also affects
all implementors of the trait. This commit removes the attribute and fixes up
implementors accordingly. The primary implementation which was lost was the
ability to compare `&[T]` and `Vec<T>` (in that order).
This change also modifies the `assert_eq!` macro to not consider both directions
of equality, only the one given in the left/right forms to the macro. This
modification is motivated due to the fact that `&[T] == Vec<T>` no longer
compiles, causing hundreds of errors in unit tests in the standard library (and
likely throughout the community as well).
cc #19470
[breaking-change]
---
src/doc/trpl/macros.md | 6 +++---
src/libcollections/linked_list.rs | 2 +-
src/libcollections/vec.rs | 22 +++++++++++-----------
src/libcollectionstest/enum_set.rs | 22 +++++++++++-----------
src/libcollectionstest/str.rs | 2 +-
src/libcollectionstest/vec_deque.rs | 12 ++++++------
src/libcore/cmp.rs | 1 -
src/libcore/cmp_macros.rs | 13 +++++--------
src/libcore/iter.rs | 11 +++++------
src/libcore/macros.rs | 12 +++++-------
src/libcoretest/mem.rs | 2 +-
src/libfmt_macros/lib.rs | 2 +-
src/librustc_driver/test.rs | 11 +++++------
src/libstd/collections/hash/set.rs | 2 +-
src/libstd/old_io/buffered.rs | 2 +-
src/libstd/old_io/util.rs | 20 ++++++++++----------
src/libstd/old_path/posix.rs | 13 ++++++-------
src/libsyntax/util/small_vector.rs | 6 +++---
src/test/run-fail/assert-eq-macro-panic.rs | 2 +-
19 files changed, 77 insertions(+), 86 deletions(-)
diff --git a/src/doc/trpl/macros.md b/src/doc/trpl/macros.md
index 7da36043f6c..7e19ec94ee7 100644
--- a/src/doc/trpl/macros.md
+++ b/src/doc/trpl/macros.md
@@ -37,7 +37,7 @@ number of elements.
```rust
let x: Vec<u32> = vec![1, 2, 3];
-# assert_eq!(&[1,2,3], &x);
+# assert_eq!(x, [1, 2, 3]);
```
This can't be an ordinary function, because it takes any number of arguments.
@@ -51,7 +51,7 @@ let x: Vec<u32> = {
temp_vec.push(3);
temp_vec
};
-# assert_eq!(&[1,2,3], &x);
+# assert_eq!(x, [1, 2, 3]);
```
We can implement this shorthand, using a macro: [^actual]
@@ -73,7 +73,7 @@ macro_rules! vec {
};
}
# fn main() {
-# assert_eq!([1,2,3], vec![1,2,3]);
+# assert_eq!(vec![1,2,3], [1, 2, 3]);
# }
```
diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs
index 52da4902b75..56a811cc4a6 100644
--- a/src/libcollections/linked_list.rs
+++ b/src/libcollections/linked_list.rs
@@ -1079,7 +1079,7 @@ mod test {
thread::spawn(move || {
check_links(&n);
let a: &[_] = &[&1,&2,&3];
- assert_eq!(a, n.iter().collect::<Vec<_>>());
+ assert_eq!(a, &n.iter().collect::<Vec<_>>()[..]);
}).join().ok().unwrap();
}
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 3595288a6c9..451565e8feb 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1533,22 +1533,22 @@ impl<T> Extend<T> for Vec<T> {
}
__impl_slice_eq1! { Vec<A>, Vec<B> }
-__impl_slice_eq2! { Vec<A>, &'b [B] }
-__impl_slice_eq2! { Vec<A>, &'b mut [B] }
-__impl_slice_eq2! { Cow<'a, [A]>, &'b [B], Clone }
-__impl_slice_eq2! { Cow<'a, [A]>, &'b mut [B], Clone }
-__impl_slice_eq2! { Cow<'a, [A]>, Vec<B>, Clone }
+__impl_slice_eq1! { Vec<A>, &'b [B] }
+__impl_slice_eq1! { Vec<A>, &'b mut [B] }
+__impl_slice_eq1! { Cow<'a, [A]>, &'b [B], Clone }
+__impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B], Clone }
+__impl_slice_eq1! { Cow<'a, [A]>, Vec<B>, Clone }
macro_rules! array_impls {
($($N: expr)+) => {
$(
// NOTE: some less important impls are omitted to reduce code bloat
- __impl_slice_eq2! { Vec<A>, [B; $N] }
- __impl_slice_eq2! { Vec<A>, &'b [B; $N] }
- // __impl_slice_eq2! { Vec<A>, &'b mut [B; $N] }
- // __impl_slice_eq2! { Cow<'a, [A]>, [B; $N], Clone }
- // __impl_slice_eq2! { Cow<'a, [A]>, &'b [B; $N], Clone }
- // __impl_slice_eq2! { Cow<'a, [A]>, &'b mut [B; $N], Clone }
+ __impl_slice_eq1! { Vec<A>, [B; $N] }
+ __impl_slice_eq1! { Vec<A>, &'b [B; $N] }
+ // __impl_slice_eq1! { Vec<A>, &'b mut [B; $N] }
+ // __impl_slice_eq1! { Cow<'a, [A]>, [B; $N], Clone }
+ // __impl_slice_eq1! { Cow<'a, [A]>, &'b [B; $N], Clone }
+ // __impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B; $N], Clone }
)+
}
}
diff --git a/src/libcollectionstest/enum_set.rs b/src/libcollectionstest/enum_set.rs
index f04367147cb..a748541fca5 100644
--- a/src/libcollectionstest/enum_set.rs
+++ b/src/libcollectionstest/enum_set.rs
@@ -153,19 +153,19 @@ fn test_iterator() {
e1.insert(A);
let elems: Vec<_> = e1.iter().collect();
- assert_eq!([A], elems);
+ assert_eq!(elems, [A]);
e1.insert(C);
let elems: Vec<_> = e1.iter().collect();
- assert_eq!([A,C], elems);
+ assert_eq!(elems, [A,C]);
e1.insert(C);
let elems: Vec<_> = e1.iter().collect();
- assert_eq!([A,C], elems);
+ assert_eq!(elems, [A,C]);
e1.insert(B);
let elems: Vec<_> = e1.iter().collect();
- assert_eq!([A,B,C], elems);
+ assert_eq!(elems, [A,B,C]);
}
///////////////////////////////////////////////////////////////////////////
@@ -183,35 +183,35 @@ fn test_operators() {
let e_union = e1 | e2;
let elems: Vec<_> = e_union.iter().collect();
- assert_eq!([A,B,C], elems);
+ assert_eq!(elems, [A,B,C]);
let e_intersection = e1 & e2;
let elems: Vec<_> = e_intersection.iter().collect();
- assert_eq!([C], elems);
+ assert_eq!(elems, [C]);
// Another way to express intersection
let e_intersection = e1 - (e1 - e2);
let elems: Vec<_> = e_intersection.iter().collect();
- assert_eq!([C], elems);
+ assert_eq!(elems, [C]);
let e_subtract = e1 - e2;
let elems: Vec<_> = e_subtract.iter().collect();
- assert_eq!([A], elems);
+ assert_eq!(elems, [A]);
// Bitwise XOR of two sets, aka symmetric difference
let e_symmetric_diff = e1 ^ e2;
let elems: Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
+ assert_eq!(elems, [A,B]);
// Another way to express symmetric difference
let e_symmetric_diff = (e1 - e2) | (e2 - e1);
let elems: Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
+ assert_eq!(elems, [A,B]);
// Yet another way to express symmetric difference
let e_symmetric_diff = (e1 | e2) - (e1 & e2);
let elems: Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
+ assert_eq!(elems, [A,B]);
}
#[test]
diff --git a/src/libcollectionstest/str.rs b/src/libcollectionstest/str.rs
index 5cfa8009054..ef3373a3596 100644
--- a/src/libcollectionstest/str.rs
+++ b/src/libcollectionstest/str.rs
@@ -83,7 +83,7 @@ fn test_collect() {
fn test_into_bytes() {
let data = String::from_str("asdf");
let buf = data.into_bytes();
- assert_eq!(b"asdf", buf);
+ assert_eq!(buf, b"asdf");
}
#[test]
diff --git a/src/libcollectionstest/vec_deque.rs b/src/libcollectionstest/vec_deque.rs
index fe752d5a7e1..f78356fe392 100644
--- a/src/libcollectionstest/vec_deque.rs
+++ b/src/libcollectionstest/vec_deque.rs
@@ -821,7 +821,7 @@ fn test_as_slices() {
let (left, right) = ring.as_slices();
let expected: Vec<_> = (0..i+1).collect();
- assert_eq!(left, expected);
+ assert_eq!(left, &expected[..]);
assert_eq!(right, []);
}
@@ -830,8 +830,8 @@ fn test_as_slices() {
let (left, right) = ring.as_slices();
let expected_left: Vec<_> = (-last..j+1).rev().collect();
let expected_right: Vec<_> = (0..first).collect();
- assert_eq!(left, expected_left);
- assert_eq!(right, expected_right);
+ assert_eq!(left, &expected_left[..]);
+ assert_eq!(right, &expected_right[..]);
}
assert_eq!(ring.len() as i32, cap);
@@ -849,7 +849,7 @@ fn test_as_mut_slices() {
let (left, right) = ring.as_mut_slices();
let expected: Vec<_> = (0..i+1).collect();
- assert_eq!(left, expected);
+ assert_eq!(left, &expected[..]);
assert_eq!(right, []);
}
@@ -858,8 +858,8 @@ fn test_as_mut_slices() {
let (left, right) = ring.as_mut_slices();
let expected_left: Vec<_> = (-last..j+1).rev().collect();
let expected_right: Vec<_> = (0..first).collect();
- assert_eq!(left, expected_left);
- assert_eq!(right, expected_right);
+ assert_eq!(left, &expected_left[..]);
+ assert_eq!(right, &expected_right[..]);
}
assert_eq!(ring.len() as i32, cap);
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 9b8b59ec8ce..859cab4225e 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -64,7 +64,6 @@ use option::Option::{self, Some, None};
/// inverse of `ne`; that is, `!(a == b)` if and only if `a != b`.
#[lang="eq"]
#[stable(feature = "rust1", since = "1.0.0")]
-#[old_orphan_check]
pub trait PartialEq<Rhs: ?Sized = Self> {
/// This method tests for `self` and `other` values to be equal, and is used by `==`.
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/cmp_macros.rs b/src/libcore/cmp_macros.rs
index 18357bac9e6..95dab3d165a 100644
--- a/src/libcore/cmp_macros.rs
+++ b/src/libcore/cmp_macros.rs
@@ -15,8 +15,11 @@
#[macro_export]
macro_rules! __impl_slice_eq1 {
($Lhs: ty, $Rhs: ty) => {
+ __impl_slice_eq1! { $Lhs, $Rhs, Sized }
+ };
+ ($Lhs: ty, $Rhs: ty, $Bound: ident) => {
#[stable(feature = "rust1", since = "1.0.0")]
- impl<'a, 'b, A, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
+ impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &$Rhs) -> bool { &self[..] == &other[..] }
#[inline]
@@ -31,13 +34,7 @@ macro_rules! __impl_slice_eq2 {
__impl_slice_eq2! { $Lhs, $Rhs, Sized }
};
($Lhs: ty, $Rhs: ty, $Bound: ident) => {
- #[stable(feature = "rust1", since = "1.0.0")]
- impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
- #[inline]
- fn eq(&self, other: &$Rhs) -> bool { &self[..] == &other[..] }
- #[inline]
- fn ne(&self, other: &$Rhs) -> bool { &self[..] != &other[..] }
- }
+ __impl_slice_eq1!($Lhs, $Rhs, $Bound);
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b, A: $Bound, B> PartialEq<$Lhs> for $Rhs where B: PartialEq<A> {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 44d48f9f4bf..1495d1d584e 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -530,10 +530,9 @@ pub trait Iterator {
/// # Examples
///
/// ```
- /// # #![feature(core)]
- /// let a = [1, 2, 3, 4, 5];
- /// let b: Vec<_> = a.iter().cloned().collect();
- /// assert_eq!(a, b);
+ /// let expected = [1, 2, 3, 4, 5];
+ /// let actual: Vec<_> = expected.iter().cloned().collect();
+ /// assert_eq!(actual, expected);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
@@ -927,8 +926,8 @@ pub trait Iterator {
/// # #![feature(core)]
/// let a = [(1, 2), (3, 4)];
/// let (left, right): (Vec<_>, Vec<_>) = a.iter().cloned().unzip();
- /// assert_eq!([1, 3], left);
- /// assert_eq!([2, 4], right);
+ /// assert_eq!(left, [1, 3]);
+ /// assert_eq!(right, [2, 4]);
/// ```
#[unstable(feature = "core", reason = "recent addition")]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index d5a7c1d6b26..e8959299d72 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -66,10 +66,10 @@ macro_rules! assert {
);
}
-/// Asserts that two expressions are equal to each other, testing equality in
-/// both directions.
+/// Asserts that two expressions are equal to each other.
///
-/// On panic, this macro will print the values of the expressions.
+/// On panic, this macro will print the values of the expressions with their
+/// debug representations.
///
/// # Examples
///
@@ -84,10 +84,8 @@ macro_rules! assert_eq {
($left:expr , $right:expr) => ({
match (&($left), &($right)) {
(left_val, right_val) => {
- // check both directions of equality....
- if !((*left_val == *right_val) &&
- (*right_val == *left_val)) {
- panic!("assertion failed: `(left == right) && (right == left)` \
+ if !(*left_val == *right_val) {
+ panic!("assertion failed: `(left == right)` \
(left: `{:?}`, right: `{:?}`)", *left_val, *right_val)
}
}
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
index fae36787c3d..5bc08376d25 100644
--- a/src/libcoretest/mem.rs
+++ b/src/libcoretest/mem.rs
@@ -103,7 +103,7 @@ fn test_transmute() {
}
unsafe {
- assert_eq!([76], transmute::<_, Vec<u8>>("L".to_string()));
+ assert_eq!(transmute::<_, Vec<u8>>("L".to_string()), [76]);
}
}
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 9b220409ef5..a7be6a7fcf0 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -446,7 +446,7 @@ mod tests {
fn same(fmt: &'static str, p: &[Piece<'static>]) {
let parser = Parser::new(fmt);
- assert!(p == parser.collect::<Vec<Piece<'static>>>());
+ assert!(parser.collect::<Vec<Piece<'static>>>() == p);
}
fn fmtdflt() -> FormatSpec<'static> {
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
index fcb0b9bdd3c..b0fc5fbcb50 100644
--- a/src/librustc_driver/test.rs
+++ b/src/librustc_driver/test.rs
@@ -808,12 +808,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!([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);
+ assert_eq!(walked, [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]);
})
}
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 87380471c80..5fbc21797ab 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -1192,7 +1192,7 @@ mod test_set {
};
let v = hs.into_iter().collect::<Vec<char>>();
- assert!(['a', 'b'] == v || ['b', 'a'] == v);
+ assert!(v == ['a', 'b'] || v == ['b', 'a']);
}
#[test]
diff --git a/src/libstd/old_io/buffered.rs b/src/libstd/old_io/buffered.rs
index ad6cac62173..68aa7e4770f 100644
--- a/src/libstd/old_io/buffered.rs
+++ b/src/libstd/old_io/buffered.rs
@@ -548,7 +548,7 @@ mod test {
let mut w = BufferedWriter::with_capacity(3, Vec::new());
w.write_all(&[0, 1]).unwrap();
let a: &[_] = &[];
- assert_eq!(a, &w.get_ref()[..]);
+ assert_eq!(&w.get_ref()[..], a);
let w = w.into_inner();
let a: &[_] = &[0, 1];
assert_eq!(a, &w[..]);
diff --git a/src/libstd/old_io/util.rs b/src/libstd/old_io/util.rs
index 604099f1178..a5ecb98334a 100644
--- a/src/libstd/old_io/util.rs
+++ b/src/libstd/old_io/util.rs
@@ -334,7 +334,7 @@ mod test {
let mut r = MemReader::new(vec!(0, 1, 2));
{
let mut r = LimitReader::new(r.by_ref(), 4);
- assert_eq!([0, 1, 2], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]);
}
}
@@ -343,9 +343,9 @@ mod test {
let mut r = MemReader::new(vec!(0, 1, 2));
{
let mut r = LimitReader::new(r.by_ref(), 2);
- assert_eq!([0, 1], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [0, 1]);
}
- assert_eq!([2], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [2]);
}
#[test]
@@ -355,7 +355,7 @@ mod test {
assert_eq!(3, r.limit());
assert_eq!(0, r.read_byte().unwrap());
assert_eq!(2, r.limit());
- assert_eq!([1, 2], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [1, 2]);
assert_eq!(0, r.limit());
}
@@ -364,7 +364,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!([], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), []);
}
#[test]
@@ -380,7 +380,7 @@ mod test {
let mut s = ZeroReader;
let mut buf = vec![1, 2, 3];
assert_eq!(s.read(&mut buf), Ok(3));
- assert_eq!([0, 0, 0], buf);
+ assert_eq!(buf, [0, 0, 0]);
}
#[test]
@@ -423,16 +423,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!([0, 1, 2, 3], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [0, 1, 2, 3]);
}
#[test]
fn test_tee_reader() {
let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
Vec::new());
- assert_eq!([0, 1, 2], r.read_to_end().unwrap());
+ assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]);
let (_, w) = r.into_inner();
- assert_eq!([0, 1, 2], w);
+ assert_eq!(w, [0, 1, 2]);
}
#[test]
@@ -440,7 +440,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!([0, 1, 2, 3, 4], w);
+ assert_eq!(w, [0, 1, 2, 3, 4]);
}
#[test]
diff --git a/src/libstd/old_path/posix.rs b/src/libstd/old_path/posix.rs
index bbc1756bee6..67190de08c3 100644
--- a/src/libstd/old_path/posix.rs
+++ b/src/libstd/old_path/posix.rs
@@ -126,7 +126,7 @@ impl GenericPathUnsafe for Path {
unsafe fn set_filename_unchecked<T: BytesContainer>(&mut self, filename: T) {
let filename = filename.container_as_bytes();
match self.sepidx {
- None if b".." == self.repr => {
+ None if self.repr == b".." => {
let mut v = Vec::with_capacity(3 + filename.len());
v.push_all(dot_dot_static);
v.push(SEP_BYTE);
@@ -186,7 +186,7 @@ impl GenericPath for Path {
fn dirname<'a>(&'a self) -> &'a [u8] {
match self.sepidx {
- None if b".." == self.repr => &self.repr,
+ None if self.repr == b".." => &self.repr,
None => dot_static,
Some(0) => &self.repr[..1],
Some(idx) if &self.repr[idx+1..] == b".." => &self.repr,
@@ -196,8 +196,7 @@ impl GenericPath for Path {
fn filename<'a>(&'a self) -> Option<&'a [u8]> {
match self.sepidx {
- None if b"." == self.repr ||
- b".." == self.repr => None,
+ None if self.repr == b"." || self.repr == b".." => None,
None => Some(&self.repr),
Some(idx) if &self.repr[idx+1..] == b".." => None,
Some(0) if self.repr[1..].is_empty() => None,
@@ -207,13 +206,13 @@ impl GenericPath for Path {
fn pop(&mut self) -> bool {
match self.sepidx {
- None if b"." == self.repr => false,
+ None if self.repr == b"." => false,
None => {
self.repr = vec![b'.'];
self.sepidx = None;
true
}
- Some(0) if b"/" == self.repr => false,
+ Some(0) if self.repr == b"/" => false,
Some(idx) => {
if idx == 0 {
self.repr.truncate(idx+1);
@@ -245,7 +244,7 @@ impl GenericPath for Path {
} else {
let mut ita = self.components();
let mut itb = other.components();
- if b"." == self.repr {
+ if self.repr == b"." {
return match itb.next() {
None => true,
Some(b) => b != b".."
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 5bd6591cfb0..1649934f4b1 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -226,13 +226,13 @@ mod test {
fn test_move_iter() {
let v = SmallVector::zero();
let v: Vec<isize> = v.into_iter().collect();
- assert_eq!(Vec::new(), v);
+ assert_eq!(v, Vec::new());
let v = SmallVector::one(1);
- assert_eq!([1], v.into_iter().collect::<Vec<_>>());
+ assert_eq!(v.into_iter().collect::<Vec<_>>(), [1]);
let v = SmallVector::many(vec![1, 2, 3]);
- assert_eq!([1, 2, 3], v.into_iter().collect::<Vec<_>>());
+ assert_eq!(v.into_iter().collect::<Vec<_>>(), [1, 2, 3]);
}
#[test]
diff --git a/src/test/run-fail/assert-eq-macro-panic.rs b/src/test/run-fail/assert-eq-macro-panic.rs
index fd6d69efb4f..0b35062b186 100644
--- a/src/test/run-fail/assert-eq-macro-panic.rs
+++ b/src/test/run-fail/assert-eq-macro-panic.rs
@@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14`, right: `15`)
+// error-pattern:assertion failed: `(left == right)` (left: `14`, right: `15`)
fn main() {
assert_eq!(14,15);