tests: extract common module (#504)

Extracts a module containing shared functionality which can be reused
between various tests.

Currently it just contains `to_biguint` (which has been adapted to work
with both `Uint` and `BoxedUint`)

Author: tarcieri

src/odd.rs

@@ -1,17 +1,14 @@
 //! Wrapper type for non-zero integers.
 
-use crate::{Integer, NonZero, Uint};
+use crate::{Integer, Limb, NonZero, Uint};
 use core::{cmp::Ordering, ops::Deref};
 use subtle::{Choice, ConditionallySelectable, CtOption};
 
 #[cfg(feature = "alloc")]
 use crate::BoxedUint;
 
 #[cfg(feature = "rand_core")]
-use {
-    crate::{Limb, Random},
-    rand_core::CryptoRngCore,
-};
+use {crate::Random, rand_core::CryptoRngCore};
 
 /// Wrapper type for odd integers.
 ///
@@ -75,6 +72,15 @@ impl<T> AsRef<T> for Odd<T> {
     }
 }
 
+impl<T> AsRef<[Limb]> for Odd<T>
+where
+    T: AsRef<[Limb]>,
+{
+    fn as_ref(&self) -> &[Limb] {
+        self.0.as_ref()
+    }
+}
+
 impl<T> AsRef<NonZero<T>> for Odd<T> {
     fn as_ref(&self) -> &NonZero<T> {
         self.as_nz_ref()

tests/bernstein_yang.rs

@@ -1,6 +1,9 @@
 //! Equivalence tests for Bernstein-Yang inversions.
 
-use crypto_bigint::{Encoding, Inverter, Odd, PrecomputeInverter, U256};
+mod common;
+
+use common::to_biguint;
+use crypto_bigint::{Inverter, Odd, PrecomputeInverter, U256};
 use num_bigint::BigUint;
 use num_integer::Integer;
 use num_traits::One;
@@ -13,15 +16,6 @@ use crypto_bigint::BoxedUint;
 const P: Odd<U256> =
     Odd::<U256>::from_be_hex("ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
 
-fn to_biguint(uint: &U256) -> BigUint {
-    BigUint::from_bytes_le(uint.to_le_bytes().as_ref())
-}
-
-#[cfg(feature = "alloc")]
-fn to_biguint_boxed(boxed_uint: &BoxedUint) -> BigUint {
-    BigUint::from_bytes_le(boxed_uint.to_le_bytes().as_ref())
-}
-
 prop_compose! {
     fn uint()(bytes in any::<[u8; 32]>()) -> U256 {
         U256::from_le_slice(&bytes)
@@ -53,7 +47,7 @@ proptest! {
 
         prop_assert_eq!(expected_is_some, bool::from(actual.is_some()));
 
-        if let Some(actual) = actual.into() {
+        if let Some(actual) = Option::<U256>::from(actual) {
             let inv_bi = to_biguint(&actual);
             let res = (inv_bi * x_bi) % p_bi;
             prop_assert_eq!(res, BigUint::one());
@@ -66,7 +60,7 @@ proptest! {
         let p = Odd::<BoxedUint>::from(&P);
         let x = x.rem_vartime(p.as_nz_ref()).widen(p.bits_precision());
 
-        let x_bi = to_biguint_boxed(&x);
+        let x_bi = to_biguint(&x);
         let p_bi = to_biguint(&P);
 
         let expected_is_some = x_bi.gcd(&p_bi) == BigUint::one();
@@ -75,8 +69,8 @@ proptest! {
 
         prop_assert_eq!(expected_is_some, bool::from(actual.is_some()));
 
-        if let Some(actual) = actual.into() {
-            let inv_bi = to_biguint_boxed(&actual);
+        if let Some(actual) = Option::<BoxedUint>::from(actual) {
+            let inv_bi = to_biguint(&actual);
             let res = (inv_bi * x_bi) % p_bi;
             prop_assert_eq!(res, BigUint::one());
         }

tests/boxed_monty_form.rs

@@ -2,6 +2,9 @@
 
 #![cfg(feature = "alloc")]
 
+mod common;
+
+use common::to_biguint;
 use crypto_bigint::{
     modular::{BoxedMontyForm, BoxedMontyParams},
     BoxedUint, Integer, Inverter, Limb, NonZero, Odd, PrecomputeInverter,
@@ -11,10 +14,6 @@ use num_modular::ModularUnaryOps;
 use proptest::prelude::*;
 use std::cmp::Ordering;
 
-fn to_biguint(uint: &BoxedUint) -> BigUint {
-    BigUint::from_bytes_be(&uint.to_be_bytes())
-}
-
 fn retrieve_biguint(monty_form: &BoxedMontyForm) -> BigUint {
     to_biguint(&monty_form.retrieve())
 }

tests/boxed_uint.rs

@@ -2,6 +2,9 @@
 
 #![cfg(feature = "alloc")]
 
+mod common;
+
+use common::to_biguint;
 use core::cmp::Ordering;
 use crypto_bigint::{BoxedUint, CheckedAdd, Gcd, Integer, Limb, NonZero};
 use num_bigint::BigUint;
@@ -10,10 +13,6 @@ use num_modular::ModularUnaryOps;
 use num_traits::identities::One;
 use proptest::prelude::*;
 
-fn to_biguint(uint: &BoxedUint) -> BigUint {
-    BigUint::from_bytes_be(&uint.to_be_bytes())
-}
-
 fn to_uint(big_uint: BigUint) -> BoxedUint {
     let bytes = big_uint.to_bytes_be();
     let pad_count = Limb::BYTES - (bytes.len() % Limb::BYTES);
@@ -170,7 +169,7 @@ proptest! {
         let a_bi = to_biguint(&a);
         let b_bi = to_biguint(&b);
         let expected = a_bi.invm(&b_bi);
-        let actual = Option::from(a.inv_odd_mod(&b));
+        let actual = Option::<BoxedUint>::from(a.inv_odd_mod(&b));
 
         match (expected, actual) {
             (Some(exp), Some(act)) => prop_assert_eq!(exp, to_biguint(&act).into()),

tests/common/mod.rs

@@ -0,0 +1,21 @@
+//! Common functionality shared between tests.
+
+// Different tests may use only a subset of the available functionality
+#![allow(dead_code)]
+
+use crypto_bigint::{Encoding, Limb};
+use num_bigint::BigUint;
+
+/// `Uint` to `num_bigint::BigUint`
+pub fn to_biguint<T>(uint: &T) -> BigUint
+where
+    T: AsRef<[Limb]>,
+{
+    let mut bytes = Vec::with_capacity(uint.as_ref().len() * Limb::BYTES);
+
+    for limb in uint.as_ref() {
+        bytes.extend_from_slice(&limb.to_le_bytes());
+    }
+
+    BigUint::from_bytes_le(&bytes)
+}

tests/const_monty_form.rs

@@ -1,6 +1,9 @@
 //! Equivalence tests between `crypto_bigint::ConstMontyForm` and `num-bigint`.
 
-use crypto_bigint::{impl_modulus, modular::ConstMontyParams, Encoding, Invert, Inverter, U256};
+mod common;
+
+use common::to_biguint;
+use crypto_bigint::{impl_modulus, modular::ConstMontyParams, Invert, Inverter, U256};
 use num_bigint::BigUint;
 use num_modular::ModularUnaryOps;
 use proptest::prelude::*;
@@ -13,10 +16,6 @@ impl_modulus!(
 
 type ConstMontyForm = crypto_bigint::modular::ConstMontyForm<Modulus, { U256::LIMBS }>;
 
-fn to_biguint(uint: &U256) -> BigUint {
-    BigUint::from_bytes_le(uint.to_le_bytes().as_ref())
-}
-
 fn retrieve_biguint(monty_form: &ConstMontyForm) -> BigUint {
     to_biguint(&monty_form.retrieve())
 }

tests/monty_form.rs

@@ -1,17 +1,16 @@
 //! Equivalence tests between `crypto_bigint::MontyForm` and `num-bigint`.
 
-use crypto_bigint::{Encoding, Integer, Invert, Inverter, NonZero, Odd, PrecomputeInverter, U256};
+mod common;
+
+use common::to_biguint;
+use crypto_bigint::{Integer, Invert, Inverter, NonZero, Odd, PrecomputeInverter, U256};
 use num_bigint::BigUint;
 use num_modular::ModularUnaryOps;
 use proptest::prelude::*;
 
 type MontyForm = crypto_bigint::modular::MontyForm<{ U256::LIMBS }>;
 type MontyParams = crypto_bigint::modular::MontyParams<{ U256::LIMBS }>;
 
-fn to_biguint(uint: &U256) -> BigUint {
-    BigUint::from_bytes_le(uint.to_le_bytes().as_ref())
-}
-
 fn retrieve_biguint(monty_form: &MontyForm) -> BigUint {
     to_biguint(&monty_form.retrieve())
 }

tests/uint.rs

@@ -1,5 +1,8 @@
 //! Equivalence tests between `crypto_bigint::Uint` and `num_bigint::BigUint`.
 
+mod common;
+
+use common::to_biguint;
 use crypto_bigint::{
     modular::{MontyForm, MontyParams},
     Encoding, Integer, Limb, NonZero, Odd, Word, U256,
@@ -14,10 +17,6 @@ use std::mem;
 const P: Odd<U256> =
     Odd::<U256>::from_be_hex("ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
 
-fn to_biguint(uint: &U256) -> BigUint {
-    BigUint::from_bytes_le(uint.to_le_bytes().as_ref())
-}
-
 fn to_uint(big_uint: BigUint) -> U256 {
     let mut input = [0u8; U256::BYTES];
     let encoded = big_uint.to_bytes_le();