Improve usage of variables in formatting macros (#67)

Signed-off-by: Michele Orrù <[email protected]>
Co-authored-by: Michele Orrù <[email protected]>

Author: nougzarm

src/tests/spec/test_vectors.rs

@@ -51,9 +51,8 @@ fn test_spec_testvectors() {
         // Verify the ciphersuite is supported
         assert!(
             supported_ciphersuites.contains_key(&vector.ciphersuite),
-            "Unsupported ciphersuite '{}' in test vector {}",
-            vector.ciphersuite,
-            test_name
+            "Unsupported ciphersuite '{}' in test vector {test_name}",
+            vector.ciphersuite
         );
 
         // Parse the statement from the test vector
@@ -71,8 +70,7 @@ fn test_spec_testvectors() {
         assert_eq!(
             parsed_instance.label(),
             vector.statement,
-            "parsed statement doesn't match original for {}",
-            test_name
+            "parsed statement doesn't match original for {test_name}"
         );
 
         // Create NIZK with the session_id from the test vector
@@ -90,8 +88,7 @@ fn test_spec_testvectors() {
         assert_eq!(
             computed_iv,
             vector.iv.as_slice(),
-            "Computed IV doesn't match test vector IV for {}",
-            test_name
+            "Computed IV doesn't match test vector IV for {test_name}"
         );
 
         // Generate proof with the proof generation RNG
@@ -101,70 +98,66 @@ fn test_spec_testvectors() {
         // Verify the proof matches
         assert_eq!(
             proof_bytes, vector.proof,
-            "proof bytes for test vector {} do not match",
-            test_name
+            "proof bytes for test vector {test_name} do not match"
         );
 
         // Verify the proof is valid
         let verified = nizk.verify_batchable(&proof_bytes).is_ok();
         assert!(
             verified,
-            "Fiat-Shamir Schnorr proof verification failed for {}",
-            test_name
+            "Fiat-Shamir Schnorr proof verification failed for {test_name}"
         );
     }
 }
 
 fn extract_vectors_new(path: &str) -> Result<HashMap<String, TestVector>, String> {
     use std::collections::HashMap;
 
-    let content =
-        fs::read_to_string(path).map_err(|e| format!("Unable to read JSON file: {}", e))?;
-    let root: JsonValue =
-        json::parse(&content).map_err(|e| format!("JSON parsing error: {}", e))?;
+    let content = fs::read_to_string(path).map_err(|e| format!("Unable to read JSON file: {e}"))?;
+    let root: JsonValue = json::parse(&content).map_err(|e| format!("JSON parsing error: {e}"))?;
 
     let mut vectors = HashMap::new();
 
     for (name, obj) in root.entries() {
         let ciphersuite = obj["Ciphersuite"]
             .as_str()
-            .ok_or_else(|| format!("Ciphersuite field not found for {}", name))?
+            .ok_or_else(|| format!("Ciphersuite field not found for {name}"))?
             .to_string();
 
         let session_id = Vec::from_hex(
             obj["SessionId"]
                 .as_str()
-                .ok_or_else(|| format!("SessionId field not found for {}", name))?,
+                .ok_or_else(|| format!("SessionId field not found for {name}"))?,
         )
-        .map_err(|e| format!("Invalid hex in SessionId for {}: {}", name, e))?;
+        .map_err(|e| format!("Invalid hex in SessionId for {name}: {e}"))?;
 
         let statement = Vec::from_hex(
             obj["Statement"]
                 .as_str()
-                .ok_or_else(|| format!("Statement field not found for {}", name))?,
+                .ok_or_else(|| format!("Statement field not found for {name}"))?,
         )
-        .map_err(|e| format!("Invalid hex in Statement for {}: {}", name, e))?;
+        .map_err(|e| format!("Invalid hex in Statement for {name}: {e}"))?;
 
         let witness = Vec::from_hex(
             obj["Witness"]
                 .as_str()
-                .ok_or_else(|| format!("Witness field not found for {}", name))?,
+                .ok_or_else(|| format!("Witness field not found for {name}"))?,
         )
-        .map_err(|e| format!("Invalid hex in Witness for {}: {}", name, e))?;
+        .map_err(|e| format!("Invalid hex in Witness for {name}: {e}"))?;
 
         let iv = Vec::from_hex(
             obj["IV"]
                 .as_str()
-                .ok_or_else(|| format!("IV field not found for {}", name))?,
+                .ok_or_else(|| format!("IV field not found for {name}"))?,
         )
-        .map_err(|e| format!("Invalid hex in IV for {}: {}", name, e))?;
+        .map_err(|e| format!("Invalid hex in IV for {name}: {e}"))?;
 
         let proof = Vec::from_hex(
             obj["Proof"]
                 .as_str()
-                .ok_or_else(|| format!("Proof field not found for {}", name))?,
+                .ok_or_else(|| format!("Proof field not found for {name}"))?,
         )
-        .map_err(|e| format!("Invalid hex in Proof for {}: {}", name, e))?;
+        .map_err(|e| format!("Invalid hex in Proof for {name}: {e}"))?;
 
         vectors.insert(
             name.to_string(),

src/tests/test_relations.rs

@@ -482,31 +482,27 @@ fn test_relations() {
 
         // Test the NIZK protocol
         let protocol = SchnorrProof(canonical_relation);
-        let domain_sep = format!("test-fiat-shamir-{}", relation_name)
+        let domain_sep = format!("test-fiat-shamir-{relation_name}")
             .as_bytes()
             .to_vec();
         let nizk = Nizk::<SchnorrProof<G>, Shake128DuplexSponge<G>>::new(&domain_sep, protocol);
 
         // Test both proof types
         let proof_batchable = nizk.prove_batchable(&witness, &mut OsRng).expect(&format!(
-            "Failed to create batchable proof for {}",
-            relation_name
+            "Failed to create batchable proof for {relation_name}"
         ));
         let proof_compact = nizk.prove_compact(&witness, &mut OsRng).expect(&format!(
-            "Failed to create compact proof for {}",
-            relation_name
+            "Failed to create compact proof for {relation_name}"
         ));
 
         // Verify both proof types
         assert!(
             nizk.verify_batchable(&proof_batchable).is_ok(),
-            "Batchable proof verification failed for {}",
-            relation_name
+            "Batchable proof verification failed for {relation_name}"
         );
         assert!(
             nizk.verify_compact(&proof_compact).is_ok(),
-            "Compact proof verification failed for {}",
-            relation_name
+            "Compact proof verification failed for {relation_name}"
         );
     }
 }

src/tests/test_validation_criteria.rs

@@ -249,9 +249,7 @@ mod proof_validation {
                 // Verification should fail
                 assert!(
                     nizk.verify_batchable(&proof).is_err(),
-                    "Proof verification should fail with bit {} flipped at position {}",
-                    bit,
-                    pos
+                    "Proof verification should fail with bit {bit} flipped at position {pos}"
                 );
 
                 // Restore original byte
@@ -282,8 +280,7 @@ mod proof_validation {
             // Verification should fail
             assert!(
                 nizk.verify_batchable(&proof).is_err(),
-                "Proof verification should fail with {} bytes appended",
-                size
+                "Proof verification should fail with {size} bytes appended"
             );
 
             // Restore original proof
@@ -311,8 +308,7 @@ mod proof_validation {
             // Verification should fail
             assert!(
                 nizk.verify_batchable(&prepended_proof).is_err(),
-                "Proof verification should fail with {} bytes prepended",
-                size
+                "Proof verification should fail with {size} bytes prepended"
             );
         }
     }
@@ -334,8 +330,7 @@ mod proof_validation {
                 // Verification should fail
                 assert!(
                     nizk.verify_batchable(truncated_proof).is_err(),
-                    "Proof verification should fail with {} bytes truncated",
-                    size
+                    "Proof verification should fail with {size} bytes truncated"
                 );
             }
         }
@@ -446,7 +441,7 @@ mod proof_validation {
                 );
             }
             Err(e) => {
-                println!("Proof generation failed as expected: {:?}", e);
+                println!("Proof generation failed as expected: {e:?}");
             }
         }
     }