Migrate tests to Rust nightly 1.73.

Upstream changes:
- "Stabilize thread local cell methods." rust-lang/rust#114689
- "Cleaner assert_eq! & assert_ne! panic messages" rust-lang/rust#111071

Author: gendx

src/arithmetic/fixed.rs

@@ -348,9 +348,9 @@ mod test {
         test_is_exact,
         test_ceil_precision,
         test_ratio,
-        test_ratio_invert => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(999999999)`,
- right: `FixedDecimal9(1000000000)`: R::ratio(1, a) * a != 1 for 3"),
+        test_ratio_invert => fail(r"assertion `left == right` failed: R::ratio(1, a) * a != 1 for 3
+  left: FixedDecimal9(999999999)
+ right: FixedDecimal9(1000000000)"),
         test_is_zero,
         test_zero_is_add_neutral,
         test_add_is_commutative,
@@ -363,18 +363,18 @@ mod test {
         test_mul_up_is_commutative,
         test_mul_up_integers,
         test_mul_up_wrt_mul,
-        test_invert => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(2147483649)`,
- right: `FixedDecimal9(2147483646)`: 1/(1/a) != a for 2.147483646"),
+        test_invert => fail(r"assertion `left == right` failed: 1/(1/a) != a for 2.147483646
+  left: FixedDecimal9(2147483649)
+ right: FixedDecimal9(2147483646)"),
         test_div_self,
         test_div_up_self,
         test_div_up_wrt_div,
-        test_mul_div => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(0)`,
- right: `FixedDecimal9(1)`: (a * b) / b != a for 0.000000001, 0.000000001"),
-        test_div_mul => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(0)`,
- right: `FixedDecimal9(1)`: (a / b) * b != a for 0.000000001, 0.000001024"),
+        test_mul_div => fail(r"assertion `left == right` failed: (a * b) / b != a for 0.000000001, 0.000000001
+  left: FixedDecimal9(0)
+ right: FixedDecimal9(1)"),
+        test_div_mul => fail(r"assertion `left == right` failed: (a / b) * b != a for 0.000000001, 0.000001024
+  left: FixedDecimal9(0)
+ right: FixedDecimal9(1)"),
         test_mul_by_int,
         test_div_by_int,
         test_references,
@@ -386,18 +386,18 @@ mod test {
         FixedDecimal9,
         None,
         test_add_is_associative,
-        test_mul_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(0)`,
- right: `FixedDecimal9(1)`: (a * b) * c != a * (b * c) for 0.000000001, 0.536870912, 2.147483646"),
-        test_mul_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(2)`,
- right: `FixedDecimal9(1)`: a * (b + c) != (a * b) + (a * c) for 0.000000001, 0.134217728, 1.879048191"),
+        test_mul_is_associative => fail(r"assertion `left == right` failed: (a * b) * c != a * (b * c) for 0.000000001, 0.536870912, 2.147483646
+  left: FixedDecimal9(0)
+ right: FixedDecimal9(1)"),
+        test_mul_is_distributive => fail(r"assertion `left == right` failed: a * (b + c) != (a * b) + (a * c) for 0.000000001, 0.134217728, 1.879048191
+  left: FixedDecimal9(2)
+ right: FixedDecimal9(1)"),
         test_mul_by_int_is_associative,
         test_mul_by_int_is_distributive,
         test_div_by_int_is_associative,
-        test_div_by_int_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `FixedDecimal9(1)`,
- right: `FixedDecimal9(0)`: (a + b) / c != (a / c) + (b / c) for 0.000000001, 0.000000001, 2"),
+        test_div_by_int_is_distributive => fail(r"assertion `left == right` failed: (a + b) / c != (a / c) + (b / c) for 0.000000001, 0.000000001, 2
+  left: FixedDecimal9(1)
+ right: FixedDecimal9(0)"),
         test_sum,
         test_product,
     );

src/arithmetic/fixed_big.rs

@@ -306,9 +306,9 @@ mod test {
         test_is_exact,
         test_ceil_precision,
         test_ratio,
-        test_ratio_invert => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(999999999)`,
- right: `BigFixedDecimal9(1000000000)`: R::ratio(1, a) * a != 1 for 3"),
+        test_ratio_invert => fail(r"assertion `left == right` failed: R::ratio(1, a) * a != 1 for 3
+  left: BigFixedDecimal9(999999999)
+ right: BigFixedDecimal9(1000000000)"),
         test_is_zero,
         test_zero_is_add_neutral,
         test_add_is_commutative,
@@ -321,18 +321,18 @@ mod test {
         test_mul_up_is_commutative,
         test_mul_up_integers,
         test_mul_up_wrt_mul,
-        test_invert => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(2147483649)`,
- right: `BigFixedDecimal9(2147483648)`: 1/(1/a) != a for 2.147483648"),
+        test_invert => fail(r"assertion `left == right` failed: 1/(1/a) != a for 2.147483648
+  left: BigFixedDecimal9(2147483649)
+ right: BigFixedDecimal9(2147483648)"),
         test_div_self,
         test_div_up_self,
         test_div_up_wrt_div,
-        test_mul_div => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(0)`,
- right: `BigFixedDecimal9(1)`: (a * b) / b != a for 0.000000001, 0.000000001"),
-        test_div_mul => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(0)`,
- right: `BigFixedDecimal9(1)`: (a / b) * b != a for 0.000000001, 0.000001024"),
+        test_mul_div => fail(r"assertion `left == right` failed: (a * b) / b != a for 0.000000001, 0.000000001
+  left: BigFixedDecimal9(0)
+ right: BigFixedDecimal9(1)"),
+        test_div_mul => fail(r"assertion `left == right` failed: (a / b) * b != a for 0.000000001, 0.000001024
+  left: BigFixedDecimal9(0)
+ right: BigFixedDecimal9(1)"),
         test_mul_by_int,
         test_div_by_int,
         test_references,
@@ -344,18 +344,18 @@ mod test {
         BigFixedDecimal9,
         None,
         test_add_is_associative,
-        test_mul_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(0)`,
- right: `BigFixedDecimal9(1)`: (a * b) * c != a * (b * c) for 0.000000001, 0.000000001, 1152921504.606846976"),
-        test_mul_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(281475)`,
- right: `BigFixedDecimal9(281474)`: a * (b + c) != (a * b) + (a * c) for 0.000000001, 0.033554432, 281474.976710656"),
+        test_mul_is_associative => fail(r"assertion `left == right` failed: (a * b) * c != a * (b * c) for 0.000000001, 0.000000001, 1152921504.606846976
+  left: BigFixedDecimal9(0)
+ right: BigFixedDecimal9(1)"),
+        test_mul_is_distributive => fail(r"assertion `left == right` failed: a * (b + c) != (a * b) + (a * c) for 0.000000001, 0.033554432, 281474.976710656
+  left: BigFixedDecimal9(281475)
+ right: BigFixedDecimal9(281474)"),
         test_mul_by_int_is_associative,
         test_mul_by_int_is_distributive,
         test_div_by_int_is_associative,
-        test_div_by_int_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `BigFixedDecimal9(1)`,
- right: `BigFixedDecimal9(0)`: (a + b) / c != (a / c) + (b / c) for 0.000000001, 0.000000001, 2"),
+        test_div_by_int_is_distributive => fail(r"assertion `left == right` failed: (a + b) / c != (a / c) + (b / c) for 0.000000001, 0.000000001, 2
+  left: BigFixedDecimal9(1)
+ right: BigFixedDecimal9(0)"),
         test_sum,
         test_product,
     );

src/arithmetic/float64.rs

@@ -94,37 +94,37 @@ mod test {
         test_is_exact,
         test_ceil_precision,
         test_ratio,
-        test_ratio_invert => fail(r"assertion failed: `(left == right)`
-  left: `0.9999999999999999`,
- right: `1.0`: R::ratio(1, a) * a != 1 for 49"),
+        test_ratio_invert => fail(r"assertion `left == right` failed: R::ratio(1, a) * a != 1 for 49
+  left: 0.9999999999999999
+ right: 1.0"),
         test_is_zero,
         test_zero_is_add_neutral,
         test_add_is_commutative,
         test_opposite,
         test_sub_self,
-        test_add_sub => fail(r"assertion failed: `(left == right)`
-  left: `0.9999999999999999`,
- right: `1.0`: (a + b) - b != a for 1, 0.0000000004656613430357376"),
-        test_sub_add => fail(r"assertion failed: `(left == right)`
-  left: `0.0`,
- right: `1.1920928955078125e-7`: (a - b) + b != a for 0.00000011920928955078125, 2147483646"),
+        test_add_sub => fail(r"assertion `left == right` failed: (a + b) - b != a for 1, 0.0000000004656613430357376
+  left: 0.9999999999999999
+ right: 1.0"),
+        test_sub_add => fail(r"assertion `left == right` failed: (a - b) + b != a for 0.00000011920928955078125, 2147483646
+  left: 0.0
+ right: 1.1920928955078125e-7"),
         test_one_is_mul_neutral,
         test_mul_is_commutative,
         test_mul_up_is_commutative,
         test_mul_up_integers,
         test_mul_up_wrt_mul,
-        test_invert => fail(r"assertion failed: `(left == right)`
-  left: `2147483631.0000002`,
- right: `2147483631.0`: 1/(1/a) != a for 2147483631"),
+        test_invert => fail(r"assertion `left == right` failed: 1/(1/a) != a for 2147483631
+  left: 2147483631.0000002
+ right: 2147483631.0"),
         test_div_self,
         test_div_up_self,
         test_div_up_wrt_div,
-        test_mul_div => fail(r"assertion failed: `(left == right)`
-  left: `2147483646.0000002`,
- right: `2147483646.0`: (a * b) / b != a for 2147483646, 0.000000000465661315280157"),
-        test_div_mul => fail(r"assertion failed: `(left == right)`
-  left: `0.9999999999999999`,
- right: `1.0`: (a / b) * b != a for 1, 2147483631"),
+        test_mul_div => fail(r"assertion `left == right` failed: (a * b) / b != a for 2147483646, 0.000000000465661315280157
+  left: 2147483646.0000002
+ right: 2147483646.0"),
+        test_div_mul => fail(r"assertion `left == right` failed: (a / b) * b != a for 1, 2147483631
+  left: 0.9999999999999999
+ right: 1.0"),
         test_mul_by_int,
         test_div_by_int,
         test_references,
@@ -135,27 +135,27 @@ mod test {
         f64,
         f64,
         None,
-        test_add_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `2.0000000004656617`,
- right: `2.0000000004656613`: (a + b) + c != a + (b + c) for 1, 1, 0.0000000004656615095692907"),
-        test_mul_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `9.903519996076708e27`,
- right: `9.903519996076707e27`: (a * b) * c != a * (b * c) for 2147483646, 2147483646, 2147483583"),
-        test_mul_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `4.6116857392545137e18`,
- right: `4.611685739254514e18`: a * (b + c) != (a * b) + (a * c) for 2147483646, 1, 2147483519"),
-        test_mul_by_int_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `4.190951650171264e-9`,
- right: `4.190951650171263e-9`: (a * b) * c != a * (b * c) for 0.0000000004656612944634737, 3, 3"),
-        test_mul_by_int_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `3.0000000013969848`,
- right: `3.0000000013969843`: (a + b) * c != (a * c) + (b * c) for 1, 0.0000000004656613985469087, 3"),
-        test_div_by_int_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `0.0303030303030303`,
- right: `0.030303030303030304`: (a / b) / c != a / (b * c) for 1, 3, 11"),
-        test_div_by_int_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `0.6`,
- right: `0.6000000000000001`: (a + b) / c != (a / c) + (b / c) for 1, 2, 5"),
+        test_add_is_associative => fail(r"assertion `left == right` failed: (a + b) + c != a + (b + c) for 1, 1, 0.0000000004656615095692907
+  left: 2.0000000004656617
+ right: 2.0000000004656613"),
+        test_mul_is_associative => fail(r"assertion `left == right` failed: (a * b) * c != a * (b * c) for 2147483646, 2147483646, 2147483583
+  left: 9.903519996076708e27
+ right: 9.903519996076707e27"),
+        test_mul_is_distributive => fail(r"assertion `left == right` failed: a * (b + c) != (a * b) + (a * c) for 2147483646, 1, 2147483519
+  left: 4.6116857392545137e18
+ right: 4.611685739254514e18"),
+        test_mul_by_int_is_associative => fail(r"assertion `left == right` failed: (a * b) * c != a * (b * c) for 0.0000000004656612944634737, 3, 3
+  left: 4.190951650171264e-9
+ right: 4.190951650171263e-9"),
+        test_mul_by_int_is_distributive => fail(r"assertion `left == right` failed: (a + b) * c != (a * c) + (b * c) for 1, 0.0000000004656613985469087, 3
+  left: 3.0000000013969848
+ right: 3.0000000013969843"),
+        test_div_by_int_is_associative => fail(r"assertion `left == right` failed: (a / b) / c != a / (b * c) for 1, 3, 11
+  left: 0.0303030303030303
+ right: 0.030303030303030304"),
+        test_div_by_int_is_distributive => fail(r"assertion `left == right` failed: (a + b) / c != (a / c) + (b / c) for 1, 2, 5
+  left: 0.6
+ right: 0.6000000000000001"),
         test_sum,
         test_product,
     );

src/arithmetic/ratio_i64.rs

@@ -52,19 +52,19 @@ mod test {
         i64,
         Ratio<i64>,
         None,
-        test_add_is_associative => fail(r"assertion failed: `(left == right)`
-  left: `Ratio { numer: -6148914815790568570, denom: 1537228657060915911 }`,
- right: `Ratio { numer: 4099276419306327682, denom: 512409552353638637 }`: (a + b) + c != a + (b + c) for 8, 1/2147483643, 1/2147483631"),
+        test_add_is_associative => fail(r"assertion `left == right` failed: (a + b) + c != a + (b + c) for 8, 1/2147483643, 1/2147483631
+  left: Ratio { numer: -6148914815790568570, denom: 1537228657060915911 }
+ right: Ratio { numer: 4099276419306327682, denom: 512409552353638637 }"),
         test_mul_is_associative => fail(r"denominator == 0"),
-        test_mul_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `Ratio { numer: -4294967291, denom: 42949672936 }`,
- right: `Ratio { numer: 5, denom: 21474836468 }`: a * (b + c) != (a * b) + (a * c) for 1/4, 1/2147483646, 1/2147483645"),
+        test_mul_is_distributive => fail(r"assertion `left == right` failed: a * (b + c) != (a * b) + (a * c) for 1/4, 1/2147483646, 1/2147483645
+  left: Ratio { numer: -4294967291, denom: 42949672936 }
+ right: Ratio { numer: 5, denom: 21474836468 }"),
         test_mul_by_int_is_associative,
         test_mul_by_int_is_distributive,
         test_div_by_int_is_associative,
-        test_div_by_int_is_distributive => fail(r"assertion failed: `(left == right)`
-  left: `Ratio { numer: -738197503, denom: 3026418953955049472 }`,
- right: `Ratio { numer: 2146451207, denom: 9079256861865148416 }`: (a + b) / c != (a / c) + (b / c) for 1/67108864, 1/2147483645, 65"),
+        test_div_by_int_is_distributive => fail(r"assertion `left == right` failed: (a + b) / c != (a / c) + (b / c) for 1/67108864, 1/2147483645, 65
+  left: Ratio { numer: -738197503, denom: 3026418953955049472 }
+ right: Ratio { numer: 2146451207, denom: 9079256861865148416 }"),
         test_sum,
         test_product => fail(r"denominator == 0"),
     );

src/lib.rs

@@ -16,7 +16,7 @@
 //! implemented in the corresponding module.
 
 #![forbid(missing_docs, unsafe_code)]
-#![cfg_attr(test, feature(test, local_key_cell_methods))]
+#![cfg_attr(test, feature(test))]
 
 #[cfg(test)]
 extern crate test;

src/parse.rs

@@ -239,13 +239,13 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "assertion failed: `(left == right)`\n  left: `102`,\n right: `34`")]
+    #[should_panic(expected = "assertion `left == right` failed\n  left: 102\n right: 34")]
     fn test_remove_quotes_no_quotes() {
         remove_quotes("foo");
     }
 
     #[test]
-    #[should_panic(expected = "assertion failed: `(left == right)`\n  left: `225`,\n right: `34`")]
+    #[should_panic(expected = "assertion `left == right` failed\n  left: 225\n right: 34")]
     fn test_remove_quotes_mid_utf8() {
         remove_quotes("\u{1234}foo\"");
     }
@@ -632,7 +632,7 @@ mod test {
 
     #[test]
     #[should_panic(
-        expected = "assertion failed: `(left == right)`\n  left: `1`,\n right: `2`: Tie-break order must mention all candidates"
+        expected = "assertion `left == right` failed: Tie-break order must mention all candidates\n  left: 1\n right: 2"
     )]
     fn test_parse_tie_not_all_candidates() {
         let file = r#"2 1
@@ -663,7 +663,7 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "assertion failed: `(left == right)`\n  left: `2`,\n right: `1`")]
+    #[should_panic(expected = "assertion `left == right` failed\n  left: 2\n right: 1")]
     fn test_parse_ballot_repeated_candidate() {
         let file = r#"2 1
 [nick apple banana]