[consensus::simplex] Improve test_invalid test (#3478)

Co-authored-by: Patrick O'Grady <me@patrickogrady.xyz>

Author: BrendanChou

consensus/src/simplex/mocks/mod.rs

@@ -12,3 +12,4 @@ pub mod relay;
 pub mod reporter;
 pub mod scheme;
 pub mod twins;
+pub mod wrapped;

consensus/src/simplex/mocks/reporter.rs

@@ -59,7 +59,8 @@ pub struct Reporter<E: CryptoRngCore, S: Scheme, L: ElectorConfig<S>, D: Digest>
     pub finalizes: Arc<Mutex<Participation<S::PublicKey, D>>>,
     pub finalizations: Arc<Mutex<HashMap<View, Finalization<S, D>>>>,
     pub faults: Arc<Mutex<Faults<S, D>>>,
-    pub invalid: Arc<Mutex<usize>>,
+    pub invalid_votes: Arc<Mutex<usize>>,
+    pub invalid_certificates: Arc<Mutex<usize>>,
 
     latest: Arc<Mutex<View>>,
     subscribers: Arc<Mutex<Vec<Sender<View>>>>,
@@ -90,7 +91,8 @@ where
             finalizes: Arc::new(Mutex::new(HashMap::new())),
             finalizations: Arc::new(Mutex::new(HashMap::new())),
             faults: Arc::new(Mutex::new(HashMap::new())),
-            invalid: Arc::new(Mutex::new(0)),
+            invalid_votes: Arc::new(Mutex::new(0)),
+            invalid_certificates: Arc::new(Mutex::new(0)),
             latest: Arc::new(Mutex::new(View::zero())),
             subscribers: Arc::new(Mutex::new(Vec::new())),
         }
@@ -108,6 +110,18 @@ where
             self.participants.key(leader).cloned().unwrap()
         });
     }
+
+    pub fn assert_no_faults(&self) {
+        let faults = self.faults.lock();
+        assert!(faults.is_empty(), "faults detected");
+    }
+
+    pub fn assert_no_invalid(&self) {
+        let invalid_votes = self.invalid_votes.lock();
+        let invalid_certificates = self.invalid_certificates.lock();
+        assert_eq!(*invalid_votes, 0, "invalid votes detected");
+        assert_eq!(*invalid_certificates, 0, "invalid certificates detected");
+    }
 }
 
 impl<E, S, L, D> crate::Reporter for Reporter<E, S, L, D>
@@ -123,12 +137,10 @@ where
         // We check signatures for all messages to ensure that the prover is working correctly
         // but in production this isn't necessary (as signatures are already verified in
         // consensus).
-        let verified = activity.verified();
         match &activity {
             Activity::Notarize(notarize) => {
                 if !notarize.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = notarize.encode();
@@ -153,8 +165,7 @@ where
                     &notarization.certificate,
                     &Sequential,
                 ) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_certificates.lock() += 1;
                     return;
                 }
                 let encoded = notarization.encode();
@@ -165,8 +176,7 @@ where
             }
             Activity::Nullify(nullify) => {
                 if !nullify.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = nullify.encode();
@@ -189,8 +199,7 @@ where
                     &nullification.certificate,
                     &Sequential,
                 ) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_certificates.lock() += 1;
                     return;
                 }
                 let encoded = nullification.encode();
@@ -203,8 +212,7 @@ where
             }
             Activity::Finalize(finalize) => {
                 if !finalize.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = finalize.encode();
@@ -229,8 +237,7 @@ where
                     &finalization.certificate,
                     &Sequential,
                 ) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_certificates.lock() += 1;
                     return;
                 }
                 let encoded = finalization.encode();
@@ -249,8 +256,7 @@ where
             Activity::ConflictingNotarize(conflicting) => {
                 let view = conflicting.view();
                 if !conflicting.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = conflicting.encode();
@@ -267,8 +273,7 @@ where
             Activity::ConflictingFinalize(conflicting) => {
                 let view = conflicting.view();
                 if !conflicting.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = conflicting.encode();
@@ -285,8 +290,7 @@ where
             Activity::NullifyFinalize(conflicting) => {
                 let view = conflicting.view();
                 if !conflicting.verify(&mut self.context, &self.scheme, &Sequential) {
-                    assert!(!verified);
-                    *self.invalid.lock() += 1;
+                    *self.invalid_votes.lock() += 1;
                     return;
                 }
                 let encoded = conflicting.encode();