Add basic test for LazyField, EagerField

Author: kayabaNerve

curve25519-dalek/src/hazmat.rs

@@ -18,6 +18,7 @@ pub mod lazy_field;
 mod lazy_field25519;
 pub(crate) use lazy_field25519::UnderlyingCapacity;
 
+/// An opaque view of the field element backend.
 /*
   The `Underlying` struct is exposed via the `LazyField` trait. As the underlying field
   implementations don't have safe arithmetic, we don't want to expose their arithmetic, but we must

curve25519-dalek/src/hazmat/lazy_field.rs

@@ -2,7 +2,10 @@
 
 use core::{fmt::Debug, ops::Add};
 
-use typenum::{B1, U0, Unsigned, type_operators::IsLessOrEqual};
+use typenum::{
+    B1, U0, Unsigned,
+    type_operators::{Cmp, IsLessOrEqual},
+};
 
 use ff::Field;
 
@@ -47,7 +50,12 @@ pub trait LazyField<CapacityUsed: Unsigned>:
     >(
         self,
         other: &T,
-    ) -> impl LazyField<<V as Add<CapacityUsed>>::Output, Capacity = Self::Capacity>;
+    ) -> impl Reducible<Output = <Self as Reducible>::Output>
+    + LazyField<
+        <V as Add<CapacityUsed>>::Output,
+        Capacity = Self::Capacity,
+        Underlying = Self::Underlying,
+    >;
 
     /// Multiply two lazy elements.
     ///
@@ -65,5 +73,5 @@ pub trait LazyField<CapacityUsed: Unsigned>:
 ///
 /// `LazyFieldWithCapacity<U1>` is _recommended_ due to the widespread popularity of 255-bit
 /// fields.
-pub trait LazyFieldWithCapacity<U: Unsigned> {}
-impl<U: Unsigned, F: LazyField<U0>> LazyFieldWithCapacity<U> for F {}
+pub trait LazyFieldWithCapacity<U: Unsigned + Cmp<Self::Capacity>>: LazyField<U0> {}
+impl<U: Unsigned + Cmp<Self::Capacity>, F: LazyField<U0>> LazyFieldWithCapacity<U> for F {}

curve25519-dalek/src/hazmat/lazy_field/eager.rs

@@ -220,7 +220,12 @@ impl<CapacityUsed: Unsigned + IsLessOrEqual<U256, Output = B1>, F: Field> LazyFi
     >(
         self,
         other: &T,
-    ) -> impl LazyField<<V as Add<CapacityUsed>>::Output, Capacity = Self::Capacity> {
+    ) -> impl Reducible<Output = <Self as Reducible>::Output>
+    + LazyField<
+        <V as Add<CapacityUsed>>::Output,
+        Capacity = Self::Capacity,
+        Underlying = Self::Underlying,
+    > {
         EagerField::<<V as Add<CapacityUsed>>::Output, F>(
             self.0 + other.as_underlying(),
             PhantomData,

curve25519-dalek/src/hazmat/lazy_field25519.rs

@@ -44,7 +44,12 @@ impl<CapacityUsed: Unsigned> LazyField<CapacityUsed> for FieldElement<CapacityUs
     >(
         self,
         other: &T,
-    ) -> impl LazyField<<V as Add<CapacityUsed>>::Output, Capacity = Self::Capacity> {
+    ) -> impl Reducible<Output = <Self as Reducible>::Output>
+    + LazyField<
+        <V as Add<CapacityUsed>>::Output,
+        Capacity = Self::Capacity,
+        Underlying = Self::Underlying,
+    > {
         FieldElement::<<V as Add<CapacityUsed>>::Output>::from(&self.0.0 + &other.as_underlying().0)
     }
 
@@ -56,3 +61,43 @@ impl<CapacityUsed: Unsigned> LazyField<CapacityUsed> for FieldElement<CapacityUs
         FieldElement::from(Underlying::from_bytes(&unreduced.to_bytes()))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use rand_core::{OsRng, TryRngCore};
+    use typenum::U3;
+
+    use crate::hazmat::lazy_field::{EagerField, LazyField, LazyFieldWithCapacity, Reducible};
+
+    #[test]
+    fn three_add_and_then_mul() {
+        use crate::hazmat::FieldElement;
+        use core::marker::PhantomData;
+        use ff::Field;
+
+        let mut rng = OsRng.unwrap_err();
+
+        let a = FieldElement::random(&mut rng);
+        let b = FieldElement::random(&mut rng);
+        let c = FieldElement::random(&mut rng);
+        let d = FieldElement::random(&mut rng);
+        let e = FieldElement::random(&mut rng);
+        let f = FieldElement::random(&mut rng);
+        let expected = (a + b + c) * (d + e + f);
+
+        assert_eq!(a.add(&b).add(&c).mul(&d.add(&e).add(&f)), expected);
+
+        assert_eq!(
+            EagerField(a, PhantomData::<typenum::U0>)
+                .add(&EagerField(b, PhantomData::<typenum::U0>))
+                .add(&EagerField(c, PhantomData::<typenum::U0>))
+                .mul(
+                    &EagerField(d, PhantomData::<typenum::U0>)
+                        .add(&EagerField(e, PhantomData::<typenum::U0>))
+                        .add(&EagerField(f, PhantomData::<typenum::U0>))
+                )
+                .0,
+            expected
+        );
+    }
+}