ecc::chip: Fix `print_ecc_chip`

The ECC test chip performs various checks that assume the chip will only
be synthesized with witnesses. This assumption is broken by the chip
printer test, so we fix the assumption here.

src/circuit/gadget/ecc.rs

@@ -508,7 +508,9 @@ mod tests {
     use super::chip::{EccChip, EccConfig};
     use crate::circuit::gadget::utilities::lookup_range_check::LookupRangeCheckConfig;
 
-    struct MyCircuit {}
+    struct MyCircuit {
+        test_errors: bool,
+    }
 
     #[allow(non_snake_case)]
     impl Circuit<pallas::Base> for MyCircuit {
@@ -516,7 +518,7 @@ mod tests {
         type FloorPlanner = SimpleFloorPlanner;
 
         fn without_witnesses(&self) -> Self {
-            MyCircuit {}
+            MyCircuit { test_errors: false }
         }
 
         fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
@@ -634,6 +636,7 @@ mod tests {
                     q_val,
                     &q,
                     &p_neg,
+                    self.test_errors,
                 )?;
             }
 
@@ -678,7 +681,7 @@ mod tests {
     #[test]
     fn ecc_chip() {
         let k = 13;
-        let circuit = MyCircuit {};
+        let circuit = MyCircuit { test_errors: true };
         let prover = MockProver::run(k, &circuit, vec![]).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
@@ -692,7 +695,7 @@ mod tests {
         root.fill(&WHITE).unwrap();
         let root = root.titled("Ecc Chip Layout", ("sans-serif", 60)).unwrap();
 
-        let circuit = MyCircuit {};
+        let circuit = MyCircuit { test_errors: false };
         halo2::dev::CircuitLayout::default()
             .render(13, &circuit, &root)
             .unwrap();

src/circuit/gadget/ecc/chip/add.rs

@@ -414,7 +414,9 @@ pub mod tests {
         // Check complete addition P + (-P)
         let zero = {
             let result = p.add(layouter.namespace(|| "P + (-P)"), p_neg)?;
-            assert!(result.inner().is_identity().unwrap());
+            if let Some(is_identity) = result.inner().is_identity() {
+                assert!(is_identity);
+            }
             result
         };
 

src/circuit/gadget/ecc/chip/add_incomplete.rs

@@ -176,6 +176,7 @@ pub mod tests {
         q_val: pallas::Affine,
         q: &NonIdentityPoint<pallas::Affine, EccChip>,
         p_neg: &NonIdentityPoint<pallas::Affine, EccChip>,
+        test_errors: bool,
     ) -> Result<(), Error> {
         // P + Q
         {
@@ -188,13 +189,15 @@ pub mod tests {
             result.constrain_equal(layouter.namespace(|| "constrain P + Q"), &witnessed_result)?;
         }
 
-        // P + P should return an error
-        p.add_incomplete(layouter.namespace(|| "P + P"), p)
-            .expect_err("P + P should return an error");
+        if test_errors {
+            // P + P should return an error
+            p.add_incomplete(layouter.namespace(|| "P + P"), p)
+                .expect_err("P + P should return an error");
 
-        // P + (-P) should return an error
-        p.add_incomplete(layouter.namespace(|| "P + (-P)"), p_neg)
-            .expect_err("P + (-P) should return an error");
+            // P + (-P) should return an error
+            p.add_incomplete(layouter.namespace(|| "P + (-P)"), p_neg)
+                .expect_err("P + (-P) should return an error");
+        }
 
         Ok(())
     }

src/circuit/gadget/ecc/chip/mul.rs

@@ -535,7 +535,9 @@ pub mod tests {
                     chip.load_private(layouter.namespace(|| "zero"), column, Some(scalar_val))?;
                 p.mul(layouter.namespace(|| "[0]B"), &scalar)?
             };
-            assert!(result.inner().is_identity().unwrap());
+            if let Some(is_identity) = result.inner().is_identity() {
+                assert!(is_identity);
+            }
         }
 
         // [-1]B (the largest possible base field element)

src/circuit/gadget/ecc/chip/mul_fixed/base_field_elem.rs

@@ -487,7 +487,9 @@ pub mod tests {
                     chip.load_private(layouter.namespace(|| "zero"), column, Some(scalar_fixed))?;
                 base.mul(layouter.namespace(|| "mul by zero"), scalar_fixed)?
             };
-            assert!(result.inner().is_identity().unwrap());
+            if let Some(is_identity) = result.inner().is_identity() {
+                assert!(is_identity);
+            }
         }
 
         // [-1]B is the largest base field element

src/circuit/gadget/ecc/chip/mul_fixed/full_width.rs

@@ -295,7 +295,9 @@ pub mod tests {
         {
             let scalar_fixed = pallas::Scalar::zero();
             let (result, _) = base.mul(layouter.namespace(|| "mul by zero"), Some(scalar_fixed))?;
-            assert!(result.inner().is_identity().unwrap());
+            if let Some(is_identity) = result.inner().is_identity() {
+                assert!(is_identity);
+            }
         }
 
         // [-1]B is the largest scalar field element.

src/circuit/gadget/ecc/chip/mul_fixed/short.rs

@@ -367,7 +367,9 @@ pub mod tests {
                 )?;
                 value_commit_v.mul(layouter.namespace(|| *name), magnitude_sign)?
             };
-            assert!(result.inner().is_identity().unwrap());
+            if let Some(is_identity) = result.inner().is_identity() {
+                assert!(is_identity);
+            }
         }
 
         Ok(())