improve: add some macros to generate big testing suite of curves

src/bn256/curve.rs

@@ -198,20 +198,20 @@ impl G1 {
     const SVDW_Z: Fq = Fq::ONE;
 }
 
+// MUST add `G2` later
+// The reason is that "G2::hash_to_curve" is unimplemented.
+// Hence, it causes the panic in "test_hash_to_curve".
 #[cfg(test)]
-mod tests {
+crate::tests::curve::curve_testing_suite!(G1);
+
+#[cfg(test)]
+mod extra_tests {
     use crate::arithmetic::CurveEndo;
     use crate::bn256::{Fr, G1, G2};
-    use crate::CurveExt;
     use ff::Field;
     use ff::{PrimeField, WithSmallOrderMulGroup};
     use rand_core::OsRng;
 
-    #[test]
-    fn test_hash_to_curve() {
-        crate::tests::curve::hash_to_curve_test::<G1>();
-    }
-
     #[test]
     fn test_map_to_curve() {
         crate::tests::curve::svdw_map_to_curve_test::<G1>(
@@ -264,12 +264,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_curve() {
-        crate::tests::curve::curve_tests::<G1>();
-        crate::tests::curve::curve_tests::<G2>();
-    }
-
     #[test]
     fn test_endo() {
         let z_impl = Fr::ZETA;
@@ -282,10 +276,6 @@ mod tests {
         assert_eq!(z_impl * z_impl + z_impl, -Fr::ONE);
         assert_eq!(z_other * z_other + z_other, -Fr::ONE);
 
-        let g = G1::generator();
-        assert_eq!(g * Fr::ZETA, g.endo());
-        let g = G2::generator();
-        assert_eq!(g * Fr::ZETA, g.endo());
         for _ in 0..100000 {
             let k = Fr::random(OsRng);
             let (k1, k1_neg, k2, k2_neg) = G1::decompose_scalar(&k);
@@ -300,15 +290,4 @@ mod tests {
             }
         }
     }
-
-    #[test]
-    fn test_serialization() {
-        crate::tests::curve::random_serialization_test::<G1>();
-        crate::tests::curve::random_serialization_test::<G2>();
-        #[cfg(feature = "derive_serde")]
-        {
-            crate::tests::curve::random_serde_test::<G1>();
-            crate::tests::curve::random_serde_test::<G2>();
-        }
-    }
 }

src/grumpkin/curve.rs

@@ -90,23 +90,15 @@ impl G1 {
 }
 
 #[cfg(test)]
-mod tests {
+crate::tests::curve::curve_testing_suite!(G1);
+
+#[cfg(test)]
+mod extra_tests {
     use crate::arithmetic::CurveEndo;
     use crate::grumpkin::{Fr, G1};
-    use crate::CurveExt;
     use ff::{Field, PrimeField, WithSmallOrderMulGroup};
     use rand_core::OsRng;
 
-    #[test]
-    fn test_hash_to_curve() {
-        crate::tests::curve::hash_to_curve_test::<G1>();
-    }
-
-    #[test]
-    fn test_curve() {
-        crate::tests::curve::curve_tests::<G1>();
-    }
-
     #[test]
     fn test_endo() {
         let z_impl = Fr::ZETA;
@@ -120,9 +112,6 @@ mod tests {
         assert_eq!(z_impl * z_impl + z_impl, -Fr::ONE);
         assert_eq!(z_other * z_other + z_other, -Fr::ONE);
 
-        let g = G1::generator();
-        assert_eq!(g * Fr::ZETA, g.endo());
-
         for _ in 0..100000 {
             let k = Fr::random(OsRng);
             let (k1, k1_neg, k2, k2_neg) = G1::decompose_scalar(&k);
@@ -137,11 +126,4 @@ mod tests {
             }
         }
     }
-
-    #[test]
-    fn test_serialization() {
-        crate::tests::curve::random_serialization_test::<G1>();
-        #[cfg(feature = "derive_serde")]
-        crate::tests::curve::random_serde_test::<G1>();
-    }
 }

src/pluto_eris/curve.rs

@@ -242,46 +242,8 @@ new_curve_impl!(
     |_, _| unimplemented!(),
 );
 
-#[test]
-fn test_curve_pluto() {
-    crate::tests::curve::curve_tests::<G1>();
-}
-#[test]
-fn test_curve_eris() {
-    crate::tests::curve::curve_tests::<Eris>();
-}
-#[test]
-fn test_curve_triton() {
-    crate::tests::curve::curve_tests::<G2>();
-}
-
-#[test]
-fn test_serialization() {
-    crate::tests::curve::random_serialization_test::<G1>();
-    crate::tests::curve::random_serialization_test::<Eris>();
-    crate::tests::curve::random_serialization_test::<G2>();
-    #[cfg(feature = "derive_serde")]
-    crate::tests::curve::random_serde_test::<G1>();
-    #[cfg(feature = "derive_serde")]
-    crate::tests::curve::random_serde_test::<Eris>();
-    #[cfg(feature = "derive_serde")]
-    crate::tests::curve::random_serde_test::<G2>();
-}
-
-#[test]
-fn test_hash_to_curve() {
-    crate::tests::curve::hash_to_curve_test::<G1>();
-    crate::tests::curve::hash_to_curve_test::<Eris>();
-}
-
-#[test]
-fn test_endo_consistency() {
-    let g = Eris::generator();
-    assert_eq!(g * Fp::ZETA, g.endo());
-
-    let g = G1::generator();
-    assert_eq!(g * Fq::ZETA, g.endo());
-
-    let g = G2::generator();
-    assert_eq!(g * Fq::ZETA, g.endo());
-}
+// MUST add `G2` later
+// The reason is that "G2::hash_to_curve" is unimplemented.
+// Hence, it causes the panic in "test_hash_to_curve".
+#[cfg(test)]
+crate::tests::curve::curve_testing_suite!(G1, Eris);

src/secp256k1/curve.rs

@@ -269,39 +269,16 @@ pub(crate) fn iso_map_secp256k1(rp: IsoSecp256k1) -> Secp256k1 {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_curve() {
-        crate::tests::curve::curve_tests::<Secp256k1>();
-    }
-
-    #[test]
-    fn test_hash_to_curve() {
-        crate::tests::curve::hash_to_curve_test::<Secp256k1>();
-    }
-
-    #[test]
-    fn test_serialization() {
-        crate::tests::curve::random_serialization_test::<Secp256k1>();
-        #[cfg(feature = "derive_serde")]
-        crate::tests::curve::random_serde_test::<Secp256k1>();
-    }
+crate::tests::curve::curve_testing_suite!(Secp256k1);
 
-    #[test]
-    fn test_endo_consistency() {
-        let g = Secp256k1::generator();
-        assert_eq!(g * Fq::ZETA, g.endo());
-    }
+#[cfg(test)]
+mod extra_tests {
+    use super::*;
+    use ff::FromUniformBytes;
+    use rand_core::OsRng;
 
     #[test]
     fn ecdsa_example() {
-        use crate::group::Curve;
-        use crate::CurveAffine;
-        use ff::FromUniformBytes;
-        use rand_core::OsRng;
-
         fn mod_n(x: Fp) -> Fq {
             let mut x_repr = [0u8; 32];
             x_repr.copy_from_slice(x.to_repr().as_ref());

src/secp256k1/fp.rs

@@ -291,7 +291,10 @@ impl WithSmallOrderMulGroup<3> for Fp {
 extend_field_legendre!(Fp);
 
 #[cfg(test)]
-mod test {
+crate::tests::field::field_testing_suite!(Fp);
+
+#[cfg(test)]
+mod extra_tests {
     use super::*;
     use ff::Field;
     use rand_core::OsRng;
@@ -340,29 +343,12 @@ mod test {
         assert_eq!(Fp::ROOT_OF_UNITY_INV, Fp::ROOT_OF_UNITY.invert().unwrap());
     }
 
-    #[test]
-    fn test_field() {
-        crate::tests::field::random_field_tests::<Fp>("secp256k1 base".to_string());
-    }
-
-    #[test]
-    fn test_conversion() {
-        crate::tests::field::random_conversion_tests::<Fp>("secp256k1 base".to_string());
-    }
-
     #[test]
     #[cfg(feature = "bits")]
     fn test_bits() {
         crate::tests::field::random_bits_tests::<Fp>("secp256k1 base".to_string());
     }
 
-    #[test]
-    fn test_serialization() {
-        crate::tests::field::random_serialization_test::<Fp>("secp256k1 base".to_string());
-        #[cfg(feature = "derive_serde")]
-        crate::tests::field::random_serde_test::<Fp>("secp256k1 base".to_string());
-    }
-
     #[test]
     fn test_quadratic_residue() {
         crate::tests::field::random_quadratic_residue_test::<Fp>();

src/secp256k1/fq.rs

@@ -298,7 +298,10 @@ impl WithSmallOrderMulGroup<3> for Fq {
 extend_field_legendre!(Fq);
 
 #[cfg(test)]
-mod test {
+crate::tests::field::field_testing_suite!(Fq);
+
+#[cfg(test)]
+mod extra_tests {
     use super::*;
     use ff::Field;
     use rand_core::OsRng;
@@ -347,28 +350,12 @@ mod test {
         assert_eq!(Fq::ROOT_OF_UNITY_INV, Fq::ROOT_OF_UNITY.invert().unwrap());
     }
 
-    #[test]
-    fn test_field() {
-        crate::tests::field::random_field_tests::<Fq>("secp256k1 scalar".to_string());
-    }
-
-    #[test]
-    fn test_conversion() {
-        crate::tests::field::random_conversion_tests::<Fq>("secp256k1 scalar".to_string());
-    }
-
     #[test]
     #[cfg(feature = "bits")]
     fn test_bits() {
         crate::tests::field::random_bits_tests::<Fq>("secp256k1 scalar".to_string());
     }
 
-    #[test]
-    fn test_serialization() {
-        crate::tests::field::random_serialization_test::<Fq>("secp256k1 scalar".to_string());
-        #[cfg(feature = "derive_serde")]
-        crate::tests::field::random_serde_test::<Fq>("secp256k1 scalar".to_string());
-    }
     #[test]
     fn test_quadratic_residue() {
         crate::tests::field::random_quadratic_residue_test::<Fq>();

src/secp256r1/curve.rs

@@ -92,30 +92,16 @@ impl Secp256r1 {
 }
 
 #[cfg(test)]
-mod tests {
+crate::tests::curve::curve_testing_suite!(Secp256r1);
+
+#[cfg(test)]
+mod extra_tests {
     use super::*;
     use crate::group::Curve;
     use crate::secp256r1::{Fp, Fq, Secp256r1};
     use ff::FromUniformBytes;
     use rand_core::OsRng;
 
-    #[test]
-    fn test_hash_to_curve() {
-        crate::tests::curve::hash_to_curve_test::<Secp256r1>();
-    }
-
-    #[test]
-    fn test_curve() {
-        crate::tests::curve::curve_tests::<Secp256r1>();
-    }
-
-    #[test]
-    fn test_serialization() {
-        crate::tests::curve::random_serialization_test::<Secp256r1>();
-        #[cfg(feature = "derive_serde")]
-        crate::tests::curve::random_serde_test::<Secp256r1>();
-    }
-
     #[test]
     fn ecdsa_example() {
         fn mod_n(x: Fp) -> Fq {

src/secp256r1/fp.rs

@@ -309,7 +309,10 @@ impl WithSmallOrderMulGroup<3> for Fp {
 extend_field_legendre!(Fp);
 
 #[cfg(test)]
-mod test {
+crate::tests::field::field_testing_suite!(Fp);
+
+#[cfg(test)]
+mod extra_tests {
     use super::*;
     use ff::Field;
     use rand_core::OsRng;
@@ -358,29 +361,12 @@ mod test {
         assert_eq!(Fp::ROOT_OF_UNITY_INV, Fp::ROOT_OF_UNITY.invert().unwrap());
     }
 
-    #[test]
-    fn test_field() {
-        crate::tests::field::random_field_tests::<Fp>("secp256r1 base".to_string());
-    }
-
-    #[test]
-    fn test_conversion() {
-        crate::tests::field::random_conversion_tests::<Fp>("secp256r1 base".to_string());
-    }
-
     #[test]
     #[cfg(feature = "bits")]
     fn test_bits() {
         crate::tests::field::random_bits_tests::<Fp>("secp256r1 base".to_string());
     }
 
-    #[test]
-    fn test_serialization() {
-        crate::tests::field::random_serialization_test::<Fp>("secp256r1 base".to_string());
-        #[cfg(feature = "derive_serde")]
-        crate::tests::field::random_serde_test::<Fp>("secp256r1 base".to_string());
-    }
-
     #[test]
     fn test_quadratic_residue() {
         crate::tests::field::random_quadratic_residue_test::<Fp>();