about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/doc/trpl/macros.md6
-rw-r--r--src/libcollections/linked_list.rs2
-rw-r--r--src/libcollections/vec.rs22
-rw-r--r--src/libcollectionstest/enum_set.rs22
-rw-r--r--src/libcollectionstest/str.rs2
-rw-r--r--src/libcollectionstest/vec_deque.rs12
-rw-r--r--src/libcore/cmp.rs1
-rw-r--r--src/libcore/cmp_macros.rs13
-rw-r--r--src/libcore/iter.rs11
-rw-r--r--src/libcore/macros.rs12
-rw-r--r--src/libcoretest/mem.rs2
-rw-r--r--src/libfmt_macros/lib.rs2
-rw-r--r--src/librustc_driver/test.rs11
-rw-r--r--src/libstd/collections/hash/set.rs2
-rw-r--r--src/libstd/old_io/buffered.rs2
-rw-r--r--src/libstd/old_io/util.rs20
-rw-r--r--src/libstd/old_path/posix.rs13
-rw-r--r--src/libsyntax/util/small_vector.rs6
-rw-r--r--src/test/run-fail/assert-eq-macro-panic.rs2
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);
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-09-10 17:38:47 +0000