Update tests involving slice comparison

Author: tuguzT

library/alloc/src/collections/vec_deque/tests.rs

@@ -479,12 +479,12 @@ fn make_contiguous_big_head() {
 
     // 012......9876543
     assert_eq!(tester.capacity(), 15);
-    assert_eq!((&[9, 8, 7, 6, 5, 4, 3] as &[_], &[0, 1, 2] as &[_]), tester.as_slices());
+    assert_eq!(tester.as_slices(), ([9, 8, 7, 6, 5, 4, 3], [0, 1, 2]));
 
     let expected_start = tester.as_slices().1.len();
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
-    assert_eq!((&[9, 8, 7, 6, 5, 4, 3, 0, 1, 2] as &[_], &[] as &[_]), tester.as_slices());
+    assert_eq!(tester.as_slices(), ([9, 8, 7, 6, 5, 4, 3, 0, 1, 2], []));
 }
 
 #[test]
@@ -503,7 +503,7 @@ fn make_contiguous_big_tail() {
     let expected_start = 0;
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
-    assert_eq!((&[9, 8, 0, 1, 2, 3, 4, 5, 6, 7] as &[_], &[] as &[_]), tester.as_slices());
+    assert_eq!(tester.as_slices(), ([9, 8, 0, 1, 2, 3, 4, 5, 6, 7], []));
 }
 
 #[test]
@@ -525,8 +525,8 @@ fn make_contiguous_small_free() {
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
     assert_eq!(
-        (&['M', 'L', 'K', 'J', 'I', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] as &[_], &[] as &[_]),
-        tester.as_slices()
+        tester.as_slices(),
+        (['M', 'L', 'K', 'J', 'I', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'], [])
     );
 
     tester.clear();
@@ -543,8 +543,8 @@ fn make_contiguous_small_free() {
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
     assert_eq!(
-        (&['H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'I', 'J', 'K', 'L', 'M'] as &[_], &[] as &[_]),
-        tester.as_slices()
+        tester.as_slices(),
+        (['H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'I', 'J', 'K', 'L', 'M'], [])
     );
 }
 
@@ -570,12 +570,8 @@ fn make_contiguous_head_to_end() {
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
     assert_eq!(
-        (
-            &['P', 'O', 'N', 'M', 'L', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']
-                as &[_],
-            &[] as &[_]
-        ),
-        tester.as_slices()
+        tester.as_slices(),
+        (['P', 'O', 'N', 'M', 'L', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'], [])
     );
 
     tester.clear();
@@ -592,12 +588,8 @@ fn make_contiguous_head_to_end() {
     tester.make_contiguous();
     assert_eq!(tester.head, expected_start);
     assert_eq!(
-        (
-            &['K', 'J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'L', 'M', 'N', 'O', 'P']
-                as &[_],
-            &[] as &[_]
-        ),
-        tester.as_slices()
+        tester.as_slices(),
+        (['K', 'J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'L', 'M', 'N', 'O', 'P'], [])
     );
 }
 

library/alloctests/tests/vec.rs

@@ -505,10 +505,10 @@ fn zero_sized_values() {
 
 #[test]
 fn test_partition() {
-    assert_eq!([].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
-    assert_eq!([1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
-    assert_eq!([1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
-    assert_eq!([1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
+    assert_eq!([].into_iter().partition::<Vec<_>, _>(|x: &i32| *x < 3), ([], []));
+    assert_eq!([1, 2, 3].into_iter().partition::<Vec<_>, _>(|x| *x < 4), ([1, 2, 3], []));
+    assert_eq!([1, 2, 3].into_iter().partition::<Vec<_>, _>(|x| *x < 2), ([1], [2, 3]));
+    assert_eq!([1, 2, 3].into_iter().partition::<Vec<_>, _>(|x| *x < 0), ([], [1, 2, 3]));
 }
 
 #[test]

library/coretests/tests/num/flt2dec/mod.rs

@@ -194,10 +194,10 @@ where
     let v: T = TestableFloat::ldexpi(x, e);
     let decoded = decode_finite(v);
 
-    try_exact!(f(&decoded) => &mut buf, &expected, expectedk;
+    try_exact!(f(&decoded) => &mut buf, expected, expectedk;
                "exact mismatch for v={x}p{e}{t}: actual {actual:?}, expected {expected:?}",
                x = x, e = e, t = tstr);
-    try_fixed!(f(&decoded) => &mut buf, expectedk - expected.len() as i16, &expected, expectedk;
+    try_fixed!(f(&decoded) => &mut buf, expectedk - expected.len() as i16, expected, expectedk;
                "fixed mismatch for v={x}p{e}{t}: actual {actual:?}, expected {expected:?}",
                x = x, e = e, t = tstr);
 }

src/tools/rust-analyzer/crates/test-utils/src/lib.rs

@@ -361,10 +361,7 @@ fn main() {
         .map(|(range, ann)| (&text[range], ann))
         .collect::<Vec<_>>();
 
-    assert_eq!(
-        res[..3],
-        [("x", "def".into()), ("y", "def".into()), ("zoo", "type:\ni32\n".into())]
-    );
+    assert_eq!(res[..3], [("x", "def"), ("y", "def"), ("zoo", "type:\ni32\n")]);
     assert_eq!(res[3].0.len(), 115);
 }
 
@@ -384,7 +381,7 @@ fn main() {
         .map(|(range, ann)| (&text[range], ann))
         .collect::<Vec<_>>();
 
-    assert_eq!(res, [("x", "a".into()), ("y", "b".into()), ("(x,   y)", "c".into())]);
+    assert_eq!(res, [("x", "a"), ("y", "b"), ("(x,   y)", "c")]);
 }
 
 /// Returns `false` if slow tests should not run, otherwise returns `true` and