Bump ctutils v0.3.0 (#1067)

This notably removes the `(Partial)Eq` impl(s) from `Choice`, so
anywhere affected has been updated to use e.g. `to_bool` instead.

Author: tarcieri

Cargo.lock

@@ -17,7 +17,7 @@ edition = "2024"
 rust-version = "1.85"
 
 [dependencies]
-ctutils = "0.2.3"
+ctutils = "0.3"
 num-traits = { version = "0.2.19", default-features = false }
 
 # optional dependencies

Cargo.toml

@@ -371,7 +371,7 @@ where
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
-    use crate::{Choice, I128, U128};
+    use crate::{I128, U128};
 
     #[cfg(target_pointer_width = "64")]
     #[test]
@@ -450,19 +450,19 @@ mod tests {
     #[test]
     fn is_minimal() {
         let min = I128::from_be_hex("80000000000000000000000000000000");
-        assert_eq!(min.is_min(), Choice::TRUE);
+        assert!(min.is_min().to_bool());
 
         let random = I128::from_be_hex("11113333555577779999BBBBDDDDFFFF");
-        assert_eq!(random.is_min(), Choice::FALSE);
+        assert!(!random.is_min().to_bool());
     }
 
     #[test]
     fn is_maximal() {
         let max = I128::from_be_hex("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
-        assert_eq!(max.is_max(), Choice::TRUE);
+        assert!(max.is_max().to_bool());
 
         let random = I128::from_be_hex("11113333555577779999BBBBDDDDFFFF");
-        assert_eq!(random.is_max(), Choice::FALSE);
+        assert!(!random.is_max().to_bool());
     }
 
     #[test]

src/int.rs

@@ -102,7 +102,7 @@ impl<const LIMBS: usize> WrappingAdd for Int<LIMBS> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Choice, I128, U128};
+    use crate::{I128, U128};
 
     #[test]
     fn checked_add() {
@@ -217,105 +217,105 @@ mod tests {
         // lhs = MIN
 
         let (_val, overflow) = I128::MIN.overflowing_add(&I128::MIN);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         let (_val, overflow) = I128::MIN.overflowing_add(&I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         let (val, overflow) = I128::MIN.overflowing_add(&I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MIN);
 
         let (val, overflow) = I128::MIN.overflowing_add(&I128::ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, min_plus_one);
 
         let (val, overflow) = I128::MIN.overflowing_add(&I128::MAX);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MINUS_ONE);
 
         // lhs = -1
 
         let (_val, overflow) = I128::MINUS_ONE.overflowing_add(&I128::MIN);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         let (val, overflow) = I128::MINUS_ONE.overflowing_add(&I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, two.wrapping_neg());
 
         let (val, overflow) = I128::MINUS_ONE.overflowing_add(&I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MINUS_ONE);
 
         let (val, overflow) = I128::MINUS_ONE.overflowing_add(&I128::ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::ZERO);
 
         let (val, overflow) = I128::MINUS_ONE.overflowing_add(&I128::MAX);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, max_minus_one);
 
         // lhs = 0
 
         let (val, overflow) = I128::ZERO.overflowing_add(&I128::MIN);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MIN);
 
         let (val, overflow) = I128::ZERO.overflowing_add(&I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MINUS_ONE);
 
         let (val, overflow) = I128::ZERO.overflowing_add(&I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::ZERO);
 
         let (val, overflow) = I128::ZERO.overflowing_add(&I128::ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::ONE);
 
         let (val, overflow) = I128::ZERO.overflowing_add(&I128::MAX);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MAX);
 
         // lhs = 1
 
         let (val, overflow) = I128::ONE.overflowing_add(&I128::MIN);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, min_plus_one);
 
         let (val, overflow) = I128::ONE.overflowing_add(&I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::ZERO);
 
         let (val, overflow) = I128::ONE.overflowing_add(&I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::ONE);
 
         let (val, overflow) = I128::ONE.overflowing_add(&I128::ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, two);
 
         let (_val, overflow) = I128::ONE.overflowing_add(&I128::MAX);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         // lhs = MAX
 
         let (val, overflow) = I128::MAX.overflowing_add(&I128::MIN);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MINUS_ONE);
 
         let (val, overflow) = I128::MAX.overflowing_add(&I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, max_minus_one);
 
         let (val, overflow) = I128::MAX.overflowing_add(&I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
         assert_eq!(val, I128::MAX);
 
         let (_val, overflow) = I128::MAX.overflowing_add(&I128::ONE);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         let (_val, overflow) = I128::MAX.overflowing_add(&I128::MAX);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
     }
 }

src/int/add.rs

@@ -503,7 +503,7 @@ impl<const LIMBS: usize> RemAssign<&NonZero<Int<LIMBS>>> for Wrapping<Int<LIMBS>
 
 #[cfg(test)]
 mod tests {
-    use crate::{Choice, CtSelect, DivVartime, I128, Int, NonZero, One, Zero};
+    use crate::{CtSelect, DivVartime, I128, Int, NonZero, One, Zero};
 
     #[test]
     #[allow(clippy::init_numbered_fields)]
@@ -622,7 +622,7 @@ mod tests {
     fn test_checked_div_mod_floor() {
         let (quotient, remainder) =
             I128::MIN.checked_div_rem_floor(&I128::MINUS_ONE.to_nz().unwrap());
-        assert_eq!(quotient.is_some(), Choice::FALSE);
+        assert!(!quotient.is_some().to_bool());
         assert_eq!(remainder, I128::ZERO);
     }
 

src/int/div.rs

@@ -198,7 +198,7 @@ impl<const LIMBS: usize> MulAssign<&Checked<Int<LIMBS>>> for Checked<Int<LIMBS>>
 
 #[cfg(test)]
 mod tests {
-    use crate::{Choice, I64, I128, I256, Int, U64, U128, U256};
+    use crate::{I64, I128, I256, Int, U64, U128, U256};
 
     #[test]
     #[allow(clippy::init_numbered_fields)]
@@ -522,15 +522,15 @@ mod tests {
     #[test]
     fn test_checked_square() {
         let res = I128::from_i64(i64::MIN).checked_square();
-        assert_eq!(res.is_some(), Choice::TRUE);
+        assert!(res.is_some().to_bool());
         assert_eq!(
             res.unwrap(),
             U128::from_be_hex("40000000000000000000000000000000")
         );
 
         let x: I128 = I128::MINUS_ONE << 64;
         let res = x.checked_square();
-        assert_eq!(res.is_none(), Choice::TRUE)
+        assert!(res.is_none().to_bool());
     }
 
     #[test]

src/int/mul.rs

@@ -58,23 +58,23 @@ mod tests {
 
         let (res, overflow) = I128::MIN.overflowing_neg();
         assert_eq!(res, I128::MIN);
-        assert_eq!(overflow, Choice::TRUE);
+        assert!(overflow.to_bool());
 
         let (res, overflow) = I128::MINUS_ONE.overflowing_neg();
         assert_eq!(res, I128::ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
 
         let (res, overflow) = I128::ZERO.overflowing_neg();
         assert_eq!(res, I128::ZERO);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
 
         let (res, overflow) = I128::ONE.overflowing_neg();
         assert_eq!(res, I128::MINUS_ONE);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
 
         let (res, overflow) = I128::MAX.overflowing_neg();
         assert_eq!(res, min_plus_one);
-        assert_eq!(overflow, Choice::FALSE);
+        assert!(!overflow.to_bool());
     }
 
     #[test]
@@ -103,7 +103,7 @@ mod tests {
 
     #[test]
     fn checked_neg() {
-        assert_eq!(I128::MIN.checked_neg().is_none(), Choice::TRUE);
+        assert!(I128::MIN.checked_neg().is_none().to_bool());
         assert_eq!(I128::MINUS_ONE.checked_neg().unwrap(), I128::ONE);
         assert_eq!(I128::ZERO.checked_neg().unwrap(), I128::ZERO);
         assert_eq!(I128::ONE.checked_neg().unwrap(), I128::MINUS_ONE);

src/int/neg.rs

@@ -75,63 +75,70 @@ mod tests {
 
     #[test]
     fn new_from_abs_sign() {
-        assert_eq!(
-            I128::new_from_abs_sign(U128::ZERO, Choice::FALSE).is_some(),
-            Choice::TRUE
+        assert!(
+            I128::new_from_abs_sign(U128::ZERO, Choice::FALSE)
+                .is_some()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(U128::ZERO, Choice::TRUE).is_some(),
-            Choice::TRUE
+        assert!(
+            I128::new_from_abs_sign(U128::ZERO, Choice::TRUE)
+                .is_some()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(I128::MIN.abs(), Choice::FALSE).is_some(),
-            Choice::FALSE
+        assert!(
+            I128::new_from_abs_sign(I128::MIN.abs(), Choice::FALSE)
+                .is_none()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(I128::MIN.abs(), Choice::TRUE).is_some(),
-            Choice::TRUE
+        assert!(
+            I128::new_from_abs_sign(I128::MIN.abs(), Choice::TRUE)
+                .is_some()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(I128::MAX.abs(), Choice::FALSE).is_some(),
-            Choice::TRUE
+        assert!(
+            I128::new_from_abs_sign(I128::MAX.abs(), Choice::FALSE)
+                .is_some()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(I128::MAX.abs(), Choice::TRUE).is_some(),
-            Choice::TRUE
+        assert!(
+            I128::new_from_abs_sign(I128::MAX.abs(), Choice::TRUE)
+                .is_some()
+                .to_bool()
         );
-        assert_eq!(
-            I128::new_from_abs_sign(U128::MAX, Choice::TRUE).is_some(),
-            Choice::FALSE
+        assert!(
+            I128::new_from_abs_sign(U128::MAX, Choice::TRUE)
+                .is_none()
+                .to_bool()
         );
     }
 
     #[test]
     fn is_negative() {
-        assert_eq!(I128::MIN.is_negative(), Choice::TRUE);
-        assert_eq!(I128::MINUS_ONE.is_negative(), Choice::TRUE);
-        assert_eq!(I128::ZERO.is_negative(), Choice::FALSE);
-        assert_eq!(I128::ONE.is_negative(), Choice::FALSE);
-        assert_eq!(I128::MAX.is_negative(), Choice::FALSE);
+        assert!(I128::MIN.is_negative().to_bool());
+        assert!(I128::MINUS_ONE.is_negative().to_bool());
+        assert!(!I128::ZERO.is_negative().to_bool());
+        assert!(!I128::ONE.is_negative().to_bool());
+        assert!(!I128::MAX.is_negative().to_bool());
 
         let random_negative = I128::from_be_hex("91113333555577779999BBBBDDDDFFFF");
-        assert_eq!(random_negative.is_negative(), Choice::TRUE);
+        assert!(random_negative.is_negative().to_bool());
 
         let random_positive = I128::from_be_hex("71113333555577779999BBBBDDDDFFFF");
-        assert_eq!(random_positive.is_negative(), Choice::FALSE);
+        assert!(!random_positive.is_negative().to_bool());
     }
 
     #[test]
     fn is_positive() {
-        assert_eq!(I128::MIN.is_positive(), Choice::FALSE);
-        assert_eq!(I128::MINUS_ONE.is_positive(), Choice::FALSE);
-        assert_eq!(I128::ZERO.is_positive(), Choice::FALSE);
-        assert_eq!(I128::ONE.is_positive(), Choice::TRUE);
-        assert_eq!(I128::MAX.is_positive(), Choice::TRUE);
+        assert!(!I128::MIN.is_positive().to_bool());
+        assert!(!I128::MINUS_ONE.is_positive().to_bool());
+        assert!(!I128::ZERO.is_positive().to_bool());
+        assert!(I128::ONE.is_positive().to_bool());
+        assert!(I128::MAX.is_positive().to_bool());
 
         let random_negative = I128::from_be_hex("deadbeefcafebabedeadbeefcafebabe");
-        assert_eq!(random_negative.is_positive(), Choice::FALSE);
+        assert!(!random_negative.is_positive().to_bool());
 
         let random_positive = I128::from_be_hex("0badc0dedeadc0decafebabedeadcafe");
-        assert_eq!(random_positive.is_positive(), Choice::TRUE);
+        assert!(random_positive.is_positive().to_bool());
     }
 }