test: Don't print to std-out in trait test runners

These prints were spamming the test runs downstream in neptune-core.

Co-authored-by: Alan Szepieniec <alan@neptune.cash>

tasm-lib/src/traits/accessor.rs

@@ -99,18 +99,12 @@ where
     }
 
     fn test(&self) {
-        for (i, corner_case) in self
+        for corner_case in self
             .accessor
             .borrow()
             .corner_case_initial_states()
             .into_iter()
-            .enumerate()
         {
-            println!(
-                "testing {} corner case number {i}",
-                self.accessor.borrow().entrypoint(),
-            );
-
             let stdin = vec![];
             let nd = NonDeterminism::default().with_ram(corner_case.memory);
             test_rust_equivalence_given_complete_state(
@@ -128,11 +122,6 @@ where
         let mut rng: StdRng = SeedableRng::from_seed(seed);
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {} common case with seed: {:#4x?}",
-                self.accessor.borrow().entrypoint(),
-                seed
-            );
             let AccessorInitialState { stack, memory } = self
                 .accessor
                 .borrow()

tasm-lib/src/traits/algorithm.rs

@@ -122,18 +122,12 @@ where
     }
 
     fn test(&self) {
-        for (i, corner_case) in self
+        for corner_case in self
             .algorithm
             .borrow()
             .corner_case_initial_states()
             .into_iter()
-            .enumerate()
         {
-            println!(
-                "testing {} corner case number {i}",
-                self.algorithm.borrow().entrypoint(),
-            );
-
             let stdin = vec![];
             test_rust_equivalence_given_complete_state(
                 self,
@@ -150,11 +144,6 @@ where
         let mut rng: StdRng = SeedableRng::from_seed(seed);
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {} common case with seed: {:#4x?}",
-                self.algorithm.borrow().entrypoint(),
-                seed
-            );
             let AlgorithmInitialState {
                 stack,
                 nondeterminism,

tasm-lib/src/traits/closure.rs

@@ -90,11 +90,6 @@ impl<C: Closure + 'static> RustShadow for ShadowedClosure<C> {
 
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {} common case with seed: {:x?}",
-                self.closure.borrow().entrypoint(),
-                seed
-            );
             let stack = self.closure.borrow().pseudorandom_initial_state(seed, None);
 
             let stdin = vec![];

tasm-lib/src/traits/function.rs

@@ -124,15 +124,12 @@ where
 
     /// Test rust-tasm equivalence.
     fn test(&self) {
-        let entrypoint = self.function.borrow().entrypoint();
-        for (i, cornercase_test) in self
+        for cornercase_test in self
             .function
             .borrow()
             .corner_case_initial_states()
             .into_iter()
-            .enumerate()
         {
-            println!("testing {entrypoint} corner case number {i}");
             self.test_initial_state(cornercase_test);
         }
 
@@ -141,7 +138,6 @@ where
 
         for _ in 0..num_rng_states {
             let seed: [u8; 32] = rng.gen();
-            println!("testing {entrypoint} with seed: {:#03x?}", seed);
             self.test_initial_state(
                 self.function
                     .borrow()

tasm-lib/src/traits/mem_preserver.rs

@@ -110,18 +110,12 @@ where
     }
 
     fn test(&self) {
-        for (i, corner_case) in self
+        for corner_case in self
             .mem_preserver
             .borrow()
             .corner_case_initial_states()
             .into_iter()
-            .enumerate()
         {
-            println!(
-                "testing {} corner case number {i}",
-                self.mem_preserver.borrow().entrypoint(),
-            );
-
             let stdin: Vec<_> = corner_case.public_input.into();
 
             test_rust_equivalence_given_complete_state(
@@ -139,11 +133,6 @@ where
         let mut rng: StdRng = SeedableRng::from_seed(seed);
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {} common case with seed: {:#4x?}",
-                self.mem_preserver.borrow().entrypoint(),
-                seed
-            );
             let MemPreserverInitialState {
                 stack,
                 public_input,

tasm-lib/src/traits/procedure.rs

@@ -2,7 +2,6 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
-use itertools::Itertools;
 use rand::prelude::*;
 use triton_vm::prelude::*;
 
@@ -117,23 +116,13 @@ impl<P: Procedure + 'static> RustShadow for ShadowedProcedure<P> {
         let seed: [u8; 32] = thread_rng().gen();
         let mut rng: StdRng = SeedableRng::from_seed(seed);
         let procedure = &self.procedure.borrow();
-        let entrypoint = procedure.entrypoint();
-
-        for (i, corner_case) in procedure
-            .corner_case_initial_states()
-            .into_iter()
-            .enumerate()
-        {
-            println!("testing {entrypoint} corner case number {i}");
+
+        for corner_case in procedure.corner_case_initial_states().into_iter() {
             self.test_initial_state(corner_case);
         }
 
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {entrypoint} common case with seed: [{}]",
-                seed.iter().map(|h| format!("{:#04x}", h)).join(", ")
-            );
             let state = procedure.pseudorandom_initial_state(seed, None);
 
             self.test_initial_state(state);

tasm-lib/src/traits/read_only_algorithm.rs

@@ -105,18 +105,12 @@ where
     }
 
     fn test(&self) {
-        for (i, corner_case) in self
+        for corner_case in self
             .read_only_algorithm
             .borrow()
             .corner_case_initial_states()
             .into_iter()
-            .enumerate()
         {
-            println!(
-                "testing {} corner case number {i}",
-                self.read_only_algorithm.borrow().entrypoint(),
-            );
-
             let stdin = vec![];
             test_rust_equivalence_given_complete_state(
                 self,
@@ -133,11 +127,6 @@ where
         let mut rng: StdRng = SeedableRng::from_seed(seed);
         for _ in 0..num_states {
             let seed: [u8; 32] = rng.gen();
-            println!(
-                "testing {} common case with seed: {:#4x?}",
-                self.read_only_algorithm.borrow().entrypoint(),
-                seed
-            );
             let ReadOnlyAlgorithmInitialState {
                 stack,
                 nondeterminism,