test: split up tests more

dignifiedquire · dignifiedquire · commit 9abb7fa7eef1 · 2025-01-04T16:03:48.000+01:00
diff --git a/src/composed/key/builder.rs b/src/composed/key/builder.rs
@@ -486,7 +486,7 @@ mod tests {
     #[test]
     fn key_gen_25519_legacy_short() {
         let mut rng = ChaCha8Rng::seed_from_u64(0);
-        for _ in 0..100 {
+        for _ in 0..10 {
             gen_25519_legacy(&mut rng);
         }
     }
@@ -590,7 +590,7 @@ mod tests {
         for key_version in [KeyVersion::V4, KeyVersion::V6] {
             println!("key version {:?}", key_version);
 
-            for _ in 0..100 {
+            for _ in 0..10 {
                 gen_25519_rfc9580(&mut rng, key_version);
             }
         }
@@ -766,43 +766,56 @@ mod tests {
     }
 
     #[test]
-    fn key_gen_ecdsa_p256() {
+    fn key_gen_ecdsa_p256_v4() {
         let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
 
-        for key_version in [KeyVersion::V4, KeyVersion::V6] {
-            println!("key version {:?}", key_version);
+        for _ in 0..=175 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P256, ECCCurve::P256, KeyVersion::V4);
+        }
+    }
+    #[test]
+    fn key_gen_ecdsa_p256_v6() {
+        let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
 
-            for _ in 0..=175 {
-                gen_ecdsa_ecdh(&mut rng, ECCCurve::P256, ECCCurve::P256, key_version);
-            }
+        for _ in 0..=175 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P256, ECCCurve::P256, KeyVersion::V6);
         }
     }
 
     #[test]
     #[ignore]
-    fn key_gen_ecdsa_p384() {
+    fn key_gen_ecdsa_p384_v4() {
         let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
+        for _ in 0..100 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P384, ECCCurve::P384, KeyVersion::V4);
+        }
+    }
 
-        for key_version in [KeyVersion::V4, KeyVersion::V6] {
-            println!("key version {:?}", key_version);
-
-            for _ in 0..100 {
-                gen_ecdsa_ecdh(&mut rng, ECCCurve::P384, ECCCurve::P384, key_version);
-            }
+    #[test]
+    #[ignore]
+    fn key_gen_ecdsa_p384_v6() {
+        let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
+        for _ in 0..100 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P384, ECCCurve::P384, KeyVersion::V6);
         }
     }
 
     #[test]
     #[ignore]
-    fn key_gen_ecdsa_p521() {
+    fn key_gen_ecdsa_p521_v4() {
         let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
 
-        for key_version in [KeyVersion::V4, KeyVersion::V6] {
-            println!("key version {:?}", key_version);
+        for _ in 0..100 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P521, ECCCurve::P521, KeyVersion::V4);
+        }
+    }
+    #[test]
+    #[ignore]
+    fn key_gen_ecdsa_p521_v6() {
+        let mut rng = &mut ChaCha8Rng::seed_from_u64(0);
 
-            for _ in 0..100 {
-                gen_ecdsa_ecdh(&mut rng, ECCCurve::P521, ECCCurve::P521, key_version);
-            }
+        for _ in 0..100 {
+            gen_ecdsa_ecdh(&mut rng, ECCCurve::P521, ECCCurve::P521, KeyVersion::V6);
         }
     }
 
diff --git a/src/composed/message/types.rs b/src/composed/message/types.rs
@@ -1052,8 +1052,7 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_x25519_encryption_seipdv2() {
+    fn x25519_encryption_seipdv2(aead: AeadAlgorithm, sym: SymmetricKeyAlgorithm) {
         let (skey, _headers) = SignedSecretKey::from_armor_single(
             fs::File::open("./tests/autocrypt/alice@autocrypt.example.sec.asc").unwrap(),
         )
@@ -1066,30 +1065,67 @@ mod tests {
         let lit_msg = Message::new_literal("hello.txt", "hello world\n");
         let compressed_msg = lit_msg.compress(CompressionAlgorithm::ZLIB).unwrap();
 
-        for aead in [AeadAlgorithm::Ocb, AeadAlgorithm::Eax, AeadAlgorithm::Gcm] {
-            for sym in [
-                SymmetricKeyAlgorithm::AES128,
-                SymmetricKeyAlgorithm::AES192,
-                SymmetricKeyAlgorithm::AES256,
-            ] {
-                for _ in 0..1000 {
-                    let encrypted = compressed_msg
-                        .encrypt_to_keys_seipdv2(&mut rng, sym, aead, 0x06, &[&pkey][..])
-                        .unwrap();
+        for _ in 0..1000 {
+            let encrypted = compressed_msg
+                .encrypt_to_keys_seipdv2(&mut rng, sym, aead, 0x06, &[&pkey][..])
+                .unwrap();
 
-                    let armored = encrypted.to_armored_bytes(None.into()).unwrap();
-                    // fs::write("./message-x25519.asc", &armored).unwrap();
+            let armored = encrypted.to_armored_bytes(None.into()).unwrap();
+            // fs::write("./message-x25519.asc", &armored).unwrap();
 
-                    let parsed = Message::from_armor_single(&armored[..]).unwrap().0;
+            let parsed = Message::from_armor_single(&armored[..]).unwrap().0;
 
-                    let decrypted = parsed.decrypt(|| "".into(), &[&skey]).unwrap().0;
+            let decrypted = parsed.decrypt(|| "".into(), &[&skey]).unwrap().0;
 
-                    assert_eq!(compressed_msg, decrypted);
-                }
-            }
+            assert_eq!(compressed_msg, decrypted);
         }
     }
 
+    #[test]
+    fn test_x25519_encryption_seipdv2_ocb_aes128() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_eax_aes128() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_gcm_aes128() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_ocb_aes192() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_eax_aes192() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_gcm_aes192() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_ocb_aes256() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES256);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_eax_aes256() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES256);
+    }
+
+    #[test]
+    fn test_x25519_encryption_seipdv2_gcm_aes256() {
+        x25519_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES256);
+    }
+
     #[test]
     fn test_password_encryption_seipdv1() {
         let _ = pretty_env_logger::try_init();
@@ -1117,39 +1153,72 @@ mod tests {
         assert_eq!(compressed_msg, decrypted);
     }
 
-    #[test]
-    fn test_password_encryption_seipdv2() {
+    fn password_encryption_seipdv2(aead: AeadAlgorithm, sym: SymmetricKeyAlgorithm) {
         let _ = pretty_env_logger::try_init();
 
         let mut rng = ChaCha8Rng::seed_from_u64(0);
 
         let lit_msg = Message::new_literal("hello.txt", "hello world\n");
         let compressed_msg = lit_msg.compress(CompressionAlgorithm::ZLIB).unwrap();
+        let s2k = StringToKey::new_default(&mut rng);
 
-        for aead in [AeadAlgorithm::Ocb, AeadAlgorithm::Eax, AeadAlgorithm::Gcm] {
-            for sym in [
-                SymmetricKeyAlgorithm::AES128,
-                SymmetricKeyAlgorithm::AES192,
-                SymmetricKeyAlgorithm::AES256,
-            ] {
-                let s2k = StringToKey::new_default(&mut rng);
-
-                let encrypted = compressed_msg
-                    .encrypt_with_password_seipdv2(&mut rng, s2k, sym, aead, 0x06, || {
-                        "secret".into()
-                    })
-                    .unwrap();
+        let encrypted = compressed_msg
+            .encrypt_with_password_seipdv2(&mut rng, s2k, sym, aead, 0x06, || "secret".into())
+            .unwrap();
 
-                let armored = encrypted.to_armored_bytes(None.into()).unwrap();
-                // fs::write("./message-password.asc", &armored).unwrap();
+        let armored = encrypted.to_armored_bytes(None.into()).unwrap();
+        // fs::write("./message-password.asc", &armored).unwrap();
 
-                let parsed = Message::from_armor_single(&armored[..]).unwrap().0;
+        let parsed = Message::from_armor_single(&armored[..]).unwrap().0;
 
-                let decrypted = parsed.decrypt_with_password(|| "secret".into()).unwrap();
+        let decrypted = parsed.decrypt_with_password(|| "secret".into()).unwrap();
 
-                assert_eq!(compressed_msg, decrypted);
-            }
-        }
+        assert_eq!(compressed_msg, decrypted);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_ocb_aes128() {
+        password_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_eax_aes128() {
+        password_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_gcm_aes128() {
+        password_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES128);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_ocb_aes192() {
+        password_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_eax_aes192() {
+        password_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_gcm_aes192() {
+        password_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES192);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_ocb_aes256() {
+        password_encryption_seipdv2(AeadAlgorithm::Ocb, SymmetricKeyAlgorithm::AES256);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_eax_aes256() {
+        password_encryption_seipdv2(AeadAlgorithm::Eax, SymmetricKeyAlgorithm::AES256);
+    }
+
+    #[test]
+    fn test_password_encryption_seipdv2_gcm_aes256() {
+        password_encryption_seipdv2(AeadAlgorithm::Gcm, SymmetricKeyAlgorithm::AES256);
     }
 
     #[test]
diff --git a/src/types/s2k.rs b/src/types/s2k.rs
@@ -687,54 +687,56 @@ mod tests {
         }
     }
 
+    // "These messages are the literal data "Hello, world!" encrypted using AES-128 with various AEADs
     #[test]
-    fn aead_skesk_msg() {
-        let _ = pretty_env_logger::try_init();
-
-        // Tests decrypting messages
-        //
-        // "These messages are the literal data "Hello, world!" encrypted using AES-128 with various AEADs
+    fn test_aead_skesk_msg_gcm() {
+        aead_skesk_msg("./tests/unit-tests/aead/gcm.msg");
+    }
+    #[test]
+    fn test_aead_skesk_msg_eax() {
+        aead_skesk_msg("./tests/unit-tests/aead/eax.msg");
+    }
+    #[test]
+    fn test_aead_skesk_msg_ocb() {
+        aead_skesk_msg("./tests/unit-tests/aead/ocb.msg");
+    }
 
-        const MSGS: &[&str] = &[
-            "./tests/unit-tests/aead/gcm.msg",
-            "./tests/unit-tests/aead/eax.msg",
-            "./tests/unit-tests/aead/ocb.msg",
-        ];
+    /// Tests decrypting messages
+    fn aead_skesk_msg(filename: &str) {
+        let _ = pretty_env_logger::try_init();
 
         use crate::{composed::Deserializable, Message};
 
-        for filename in MSGS {
-            println!("reading {}", filename);
-            let raw_file = std::fs::File::open(filename).expect("file open");
-            let (msg, header) = Message::from_armor_single(raw_file).expect("parse");
+        println!("reading {}", filename);
+        let raw_file = std::fs::File::open(filename).expect("file open");
+        let (msg, header) = Message::from_armor_single(raw_file).expect("parse");
 
-            let decrypted = msg
-                .decrypt_with_password(|| "password".to_string())
-                .expect("decrypt");
+        let decrypted = msg
+            .decrypt_with_password(|| "password".to_string())
+            .expect("decrypt");
 
-            let Message::Literal(data) = decrypted else {
-                panic!("expected literal data")
-            };
+        let Message::Literal(data) = decrypted else {
+            panic!("expected literal data")
+        };
 
-            assert_eq!(data.data(), b"Hello, world!");
+        assert_eq!(data.data(), b"Hello, world!");
 
-            // roundtrip
-            let armored = msg
-                .to_armored_string(ArmorOptions {
-                    headers: Some(&header),
-                    include_checksum: false, // No checksum on v6
-                })
-                .expect("encode");
+        // roundtrip
+        let armored = msg
+            .to_armored_string(ArmorOptions {
+                headers: Some(&header),
+                include_checksum: false, // No checksum on v6
+            })
+            .expect("encode");
 
-            let orig_armored = std::fs::read_to_string(filename).expect("file read");
+        let orig_armored = std::fs::read_to_string(filename).expect("file read");
 
-            let orig_armored = orig_armored.replace("\r\n", "\n").replace('\r', "\n");
-            let armored = armored
-                .to_string()
-                .replace("\r\n", "\n")
-                .replace('\r', "\n");
+        let orig_armored = orig_armored.replace("\r\n", "\n").replace('\r', "\n");
+        let armored = armored
+            .to_string()
+            .replace("\r\n", "\n")
+            .replace('\r', "\n");
 
-            assert_eq!(armored, orig_armored);
-        }
+        assert_eq!(armored, orig_armored);
     }
 }
diff --git a/tests/key_test.rs b/tests/key_test.rs
@@ -1285,6 +1285,7 @@ fn test_keyid_formatters() {
 }
 
 #[test]
+#[ignore]
 fn test_encrypted_key() {
     let p = Path::new("./tests/key-with-password-123.asc");
     let mut file = read_file(p.to_path_buf());

Original file line number	Diff line number	Diff line change
`@@ -1285,6 +1285,7 @@ fn test_keyid_formatters() {`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`	`1287`	`#[test]`
	`1288`	`+#[ignore]`
`1288`	`1289`	`fn test_encrypted_key() {`
`1289`	`1290`	`let p = Path::new("./tests/key-with-password-123.asc");`
`1290`	`1291`	`let mut file = read_file(p.to_path_buf());`