subtlecrypto: Replace `NormalizedAlgorithm` with specialized variants (#34193)

* Implement specialized normalize_algorithm for "get key length" operation

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "digest"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "importKey"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "deriveBits"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "decrypt"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "generateKey"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Implement specialized normalize_algorithm for "encrypt"

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Remove normalize_algorithm

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Update WPT expectations

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Replace obj.get_unsafe() with obj.get()

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Replace BitwiseOr with LogicalOr (typo)

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

* Update more WPT expectations outside of WebCryptoAPI

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

---------

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

4 files changed, 377 insertions, 9315 deletions

diff --git a/components/script/dom/subtlecrypto.rs b/components/script/dom/subtlecrypto.rs
index 64cdae30b8d..ef38190569c 100644
--- a/components/script/dom/subtlecrypto.rs
+++ b/components/script/dom/subtlecrypto.rs
@@ -26,8 +26,8 @@ use crate::dom::bindings::codegen::Bindings::CryptoKeyBinding::{
     CryptoKeyMethods, KeyType, KeyUsage,
 };
 use crate::dom::bindings::codegen::Bindings::SubtleCryptoBinding::{
-    AesCbcParams, AesCtrParams, AesKeyAlgorithm, AesKeyGenParams, Algorithm, AlgorithmIdentifier,
-    JsonWebKey, KeyAlgorithm, KeyFormat, Pbkdf2Params, SubtleCryptoMethods,
+    AesCbcParams, AesCtrParams, AesDerivedKeyParams, AesKeyAlgorithm, AesKeyGenParams, Algorithm,
+    AlgorithmIdentifier, JsonWebKey, KeyAlgorithm, KeyFormat, Pbkdf2Params, SubtleCryptoMethods,
 };
 use crate::dom::bindings::codegen::UnionTypes::{
     ArrayBufferViewOrArrayBuffer, ArrayBufferViewOrArrayBufferOrJsonWebKey,
@@ -150,8 +150,15 @@ impl SubtleCryptoMethods for SubtleCrypto {
         comp: InRealm,
         can_gc: CanGc,
     ) -> Rc<Promise> {
-        let normalized_algorithm = normalize_algorithm(cx, &algorithm, "encrypt");
         let promise = Promise::new_in_current_realm(comp, can_gc);
+        let normalized_algorithm = match normalize_algorithm_for_encrypt_or_decrypt(cx, &algorithm)
+        {
+            Ok(algorithm) => algorithm,
+            Err(e) => {
+                promise.reject_error(e);
+                return promise;
+            },
+        };
         let data = match data {
             ArrayBufferViewOrArrayBuffer::ArrayBufferView(view) => view.to_vec(),
             ArrayBufferViewOrArrayBuffer::ArrayBuffer(buffer) => buffer.to_vec(),
@@ -161,7 +168,6 @@ impl SubtleCryptoMethods for SubtleCrypto {
         let this = Trusted::new(self);
         let trusted_promise = TrustedPromise::new(promise.clone());
         let trusted_key = Trusted::new(key);
-        let alg = normalized_algorithm.clone();
         let key_alg = key.algorithm();
         let valid_usage = key.usages().contains(&KeyUsage::Encrypt);
         let _ = task_source.queue_with_canceller(
@@ -169,39 +175,20 @@ impl SubtleCryptoMethods for SubtleCrypto {
                 let subtle = this.root();
                 let promise = trusted_promise.root();
                 let key = trusted_key.root();
+
+                if !valid_usage || normalized_algorithm.name() != key_alg {
+                    promise.reject_error(Error::InvalidAccess);
+                    return;
+                }
+
                 let cx = GlobalScope::get_cx();
                 rooted!(in(*cx) let mut array_buffer_ptr = ptr::null_mut::<JSObject>());
-                let text = match alg {
-                    Ok(NormalizedAlgorithm::AesCbcParams(key_gen_params)) => {
-                        if !valid_usage || key_gen_params.name != key_alg {
-                            Err(Error::InvalidAccess)
-                        } else {
-                            match subtle.encrypt_aes_cbc(
-                                key_gen_params, &key, &data, cx, array_buffer_ptr.handle_mut()
-                            ) {
-                                Ok(_) => Ok(array_buffer_ptr.handle()),
-                                Err(e) => Err(e),
-                            }
-                        }
-                    },
-                    Ok(NormalizedAlgorithm::AesCtrParams(key_gen_params)) => {
-                        if !valid_usage || key_gen_params.name != key_alg {
-                            Err(Error::InvalidAccess)
-                        } else {
-                            match subtle.encrypt_decrypt_aes_ctr(
-                                key_gen_params, &key, &data, cx, array_buffer_ptr.handle_mut()
-                            ) {
-                                Ok(_) => Ok(array_buffer_ptr.handle()),
-                                Err(e) => Err(e),
-                            }
-                        }
-                    },
-                    _ => Err(Error::NotSupported),
-                };
-                match text {
-                    Ok(text) => promise.resolve_native(&*text),
-                    Err(e) => promise.reject_error(e),
+
+                if let Err(e) = normalized_algorithm.encrypt(&subtle, &key, &data, cx, array_buffer_ptr.handle_mut()) {
+                    promise.reject_error(e);
+                    return;
                 }
+                promise.resolve_native(&*array_buffer_ptr.handle());
             }),
             &canceller,
         );
@@ -219,8 +206,15 @@ impl SubtleCryptoMethods for SubtleCrypto {
         comp: InRealm,
         can_gc: CanGc,
     ) -> Rc<Promise> {
-        let normalized_algorithm = normalize_algorithm(cx, &algorithm, "decrypt");
         let promise = Promise::new_in_current_realm(comp, can_gc);
+        let normalized_algorithm = match normalize_algorithm_for_encrypt_or_decrypt(cx, &algorithm)
+        {
+            Ok(algorithm) => algorithm,
+            Err(e) => {
+                promise.reject_error(e);
+                return promise;
+            },
+        };
         let data = match data {
             ArrayBufferViewOrArrayBuffer::ArrayBufferView(view) => view.to_vec(),
             ArrayBufferViewOrArrayBuffer::ArrayBuffer(buffer) => buffer.to_vec(),
@@ -230,7 +224,6 @@ impl SubtleCryptoMethods for SubtleCrypto {
         let this = Trusted::new(self);
         let trusted_promise = TrustedPromise::new(promise.clone());
         let trusted_key = Trusted::new(key);
-        let alg = normalized_algorithm.clone();
         let key_alg = key.algorithm();
         let valid_usage = key.usages().contains(&KeyUsage::Decrypt);
         let _ = task_source.queue_with_canceller(
@@ -240,37 +233,18 @@ impl SubtleCryptoMethods for SubtleCrypto {
                 let key = trusted_key.root();
                 let cx = GlobalScope::get_cx();
                 rooted!(in(*cx) let mut array_buffer_ptr = ptr::null_mut::<JSObject>());
-                let text = match alg {
-                    Ok(NormalizedAlgorithm::AesCbcParams(key_gen_params)) => {
-                        if !valid_usage || key_gen_params.name != key_alg {
-                            Err(Error::InvalidAccess)
-                        } else {
-                            match subtle.decrypt_aes_cbc(
-                                key_gen_params, &key, &data, cx, array_buffer_ptr.handle_mut()
-                            ) {
-                                Ok(_) => Ok(array_buffer_ptr.handle()),
-                                Err(e) => Err(e),
-                            }
-                        }
-                    },
-                    Ok(NormalizedAlgorithm::AesCtrParams(key_gen_params)) => {
-                        if !valid_usage || key_gen_params.name != key_alg {
-                            Err(Error::InvalidAccess)
-                        } else {
-                            match subtle.encrypt_decrypt_aes_ctr(
-                                key_gen_params, &key, &data, cx, array_buffer_ptr.handle_mut()
-                            ) {
-                                Ok(_) => Ok(array_buffer_ptr.handle()),
-                                Err(e) => Err(e),
-                            }
-                        }
-                    },
-                    _ => Err(Error::NotSupported),
-                };
-                match text {
-                    Ok(text) => promise.resolve_native(&*text),
-                    Err(e) => promise.reject_error(e),
+
+                if !valid_usage || normalized_algorithm.name() != key_alg {
+                    promise.reject_error(Error::InvalidAccess);
+                    return;
                 }
+
+                if let Err(e) = normalized_algorithm.decrypt(&subtle, &key, &data, cx, array_buffer_ptr.handle_mut()) {
+                    promise.reject_error(e);
+                    return;
+                }
+
+                promise.resolve_native(&*array_buffer_ptr.handle());
             }),
             &canceller,
         );
@@ -299,7 +273,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 3. Let normalizedAlgorithm be the result of normalizing an algorithm,
         // with alg set to algorithm and op set to "digest".
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let normalized_algorithm = match normalize_algorithm(cx, &algorithm, "digest") {
+        let normalized_algorithm = match normalize_algorithm_for_digest(cx, &algorithm) {
             Ok(normalized_algorithm) => normalized_algorithm,
             Err(e) => {
                 // Step 4. If an error occurred, return a Promise rejected with normalizedAlgorithm.
@@ -314,7 +288,6 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 6. Return promise and perform the remaining steps in parallel.
         let (task_source, canceller) = self.task_source_with_canceller();
         let trusted_promise = TrustedPromise::new(promise.clone());
-        let alg = normalized_algorithm.clone();
 
         let _ = task_source.queue_with_canceller(
             task!(generate_key: move || {
@@ -324,7 +297,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
 
                 // Step 8. Let result be the result of performing the digest operation specified by
                 // normalizedAlgorithm using algorithm, with data as message.
-                let digest = match alg.digest(&data) {
+                let digest = match normalized_algorithm.digest(&data) {
                     Ok(digest) => digest,
                     Err(e) => {
                         promise.reject_error(e);
@@ -357,27 +330,24 @@ impl SubtleCryptoMethods for SubtleCrypto {
         comp: InRealm,
         can_gc: CanGc,
     ) -> Rc<Promise> {
-        let normalized_algorithm = normalize_algorithm(cx, &algorithm, "generateKey");
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        if let Err(e) = normalized_algorithm {
-            promise.reject_error(e);
-            return promise;
-        }
+        let normalized_algorithm = match normalize_algorithm_for_generate_key(cx, &algorithm) {
+            Ok(algorithm) => algorithm,
+            Err(e) => {
+                promise.reject_error(e);
+                return promise;
+            },
+        };
 
         let (task_source, canceller) = self.task_source_with_canceller();
         let this = Trusted::new(self);
         let trusted_promise = TrustedPromise::new(promise.clone());
-        let alg = normalized_algorithm.clone();
         let _ = task_source.queue_with_canceller(
             task!(generate_key: move || {
                 let subtle = this.root();
                 let promise = trusted_promise.root();
-                let key = match alg {
-                    Ok(NormalizedAlgorithm::AesKeyGenParams(key_gen_params)) => {
-                        subtle.generate_key_aes(key_usages, key_gen_params, extractable)
-                    },
-                    _ => Err(Error::NotSupported),
-                };
+                let key = normalized_algorithm.generate_key(&subtle, key_usages, extractable);
+
                 match key {
                     Ok(key) => promise.resolve_native(&key),
                     Err(e) => promise.reject_error(e),
@@ -407,7 +377,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 2. Let normalizedAlgorithm be the result of normalizing an algorithm, with alg set to algorithm
         // and op set to "deriveBits".
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let normalized_algorithm = match normalize_algorithm(cx, &algorithm, "deriveBits") {
+        let normalized_algorithm = match normalize_algorithm_for_derive_bits(cx, &algorithm) {
             Ok(algorithm) => algorithm,
             Err(e) => {
                 // Step 3. If an error occurred, return a Promise rejected with normalizedAlgorithm.
@@ -419,7 +389,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 4. Let normalizedDerivedKeyAlgorithmImport be the result of normalizing an algorithm,
         // with alg set to derivedKeyType and op set to "importKey".
         let normalized_derived_key_algorithm_import =
-            match normalize_algorithm(cx, &derived_key_type, "importKey") {
+            match normalize_algorithm_for_import_key(cx, &derived_key_type) {
                 Ok(algorithm) => algorithm,
                 Err(e) => {
                     // Step 5. If an error occurred, return a Promise rejected with normalizedDerivedKeyAlgorithmImport.
@@ -431,7 +401,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 6. Let normalizedDerivedKeyAlgorithmLength be the result of normalizing an algorithm, with alg set
         // to derivedKeyType and op set to "get key length".
         let normalized_derived_key_algorithm_length =
-            match normalize_algorithm(cx, &derived_key_type, "get key length") {
+            match normalize_algorithm_for_get_key_length(cx, &derived_key_type) {
                 Ok(algorithm) => algorithm,
                 Err(e) => {
                     // Step 7. If an error occurred, return a Promise rejected with normalizedDerivedKeyAlgorithmLength.
@@ -536,7 +506,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         // Step 2. Let normalizedAlgorithm be the result of normalizing an algorithm,
         // with alg set to algorithm and op set to "deriveBits".
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let normalized_algorithm = match normalize_algorithm(cx, &algorithm, "deriveBits") {
+        let normalized_algorithm = match normalize_algorithm_for_derive_bits(cx, &algorithm) {
             Ok(algorithm) => algorithm,
             Err(e) => {
                 // Step 3. If an error occurred, return a Promise rejected with normalizedAlgorithm.
@@ -607,7 +577,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
         can_gc: CanGc,
     ) -> Rc<Promise> {
         let promise = Promise::new_in_current_realm(comp, can_gc);
-        let normalized_algorithm = match normalize_algorithm(cx, &algorithm, "importKey") {
+        let normalized_algorithm = match normalize_algorithm_for_import_key(cx, &algorithm) {
             Ok(algorithm) => algorithm,
             Err(e) => {
                 promise.reject_error(e);
@@ -718,28 +688,6 @@ impl SubtleCryptoMethods for SubtleCrypto {
     }
 }
 
-#[derive(Clone, Debug)]
-pub enum NormalizedAlgorithm {
-    #[allow(dead_code)]
-    Algorithm(SubtleAlgorithm),
-    AesCbcParams(SubtleAesCbcParams),
-    AesCtrParams(SubtleAesCtrParams),
-    AesKeyGenParams(SubtleAesKeyGenParams),
-    Pbkdf2Params(SubtlePbkdf2Params),
-
-    /// <https://w3c.github.io/webcrypto/#sha>
-    Sha1,
-
-    /// <https://w3c.github.io/webcrypto/#sha>
-    Sha256,
-
-    /// <https://w3c.github.io/webcrypto/#sha>
-    Sha384,
-
-    /// <https://w3c.github.io/webcrypto/#sha>
-    Sha512,
-}
-
 // These "subtle" structs are proxies for the codegen'd dicts which don't hold a DOMString
 // so they can be sent safely when running steps in parallel.
 
@@ -823,7 +771,7 @@ pub struct SubtlePbkdf2Params {
     iterations: u32,
 
     /// <https://w3c.github.io/webcrypto/#dfn-Pbkdf2Params-hash>
-    hash: Box<NormalizedAlgorithm>,
+    hash: DigestAlgorithm,
 }
 
 impl SubtlePbkdf2Params {
@@ -836,99 +784,249 @@ impl SubtlePbkdf2Params {
         let params = Self {
             salt,
             iterations: params.iterations,
-            hash: Box::new(normalize_algorithm(cx, &params.hash, "digest")?),
+            hash: normalize_algorithm_for_digest(cx, &params.hash)?,
         };
 
         Ok(params)
     }
 }
 
-/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm>
-#[allow(unsafe_code)]
-fn normalize_algorithm(
+enum GetKeyLengthAlgorithm {
+    Aes(u16),
+}
+
+#[derive(Clone, Copy, Debug)]
+enum DigestAlgorithm {
+    /// <https://w3c.github.io/webcrypto/#sha>
+    Sha1,
+
+    /// <https://w3c.github.io/webcrypto/#sha>
+    Sha256,
+
+    /// <https://w3c.github.io/webcrypto/#sha>
+    Sha384,
+
+    /// <https://w3c.github.io/webcrypto/#sha>
+    Sha512,
+}
+
+/// A normalized algorithm returned by [`normalize_algorithm`] with operation `"importKey"`
+///
+/// [`normalize_algorithm`]: https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+enum ImportKeyAlgorithm {
+    AesCbc,
+    AesCtr,
+    Pbkdf2,
+}
+
+/// A normalized algorithm returned by [`normalize_algorithm`] with operation `"deriveBits"`
+///
+/// [`normalize_algorithm`]: https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+enum DeriveBitsAlgorithm {
+    Pbkdf2(SubtlePbkdf2Params),
+}
+
+/// A normalized algorithm returned by [`normalize_algorithm`] with operation `"encrypt"` or `"decrypt"`
+///
+/// [`normalize_algorithm`]: https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+enum EncryptionAlgorithm {
+    AesCbc(SubtleAesCbcParams),
+    AesCtr(SubtleAesCtrParams),
+}
+
+/// A normalized algorithm returned by [`normalize_algorithm`] with operation `"generateKey"`
+///
+/// [`normalize_algorithm`]: https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+enum KeyGenerationAlgorithm {
+    Aes(SubtleAesKeyGenParams),
+}
+
+macro_rules! value_from_js_object {
+    ($t: ty, $cx: ident, $value: ident) => {{
+        let params_result = <$t>::new($cx, $value.handle()).map_err(|_| Error::Operation)?;
+        let ConversionResult::Success(params) = params_result else {
+            return Err(Error::Syntax);
+        };
+        params
+    }};
+}
+
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"get key length"`
+fn normalize_algorithm_for_get_key_length(
     cx: JSContext,
     algorithm: &AlgorithmIdentifier,
-    operation: &str,
-) -> Result<NormalizedAlgorithm, Error> {
+) -> Result<GetKeyLengthAlgorithm, Error> {
     match algorithm {
-        AlgorithmIdentifier::String(name) => {
-            Ok(NormalizedAlgorithm::Algorithm(name.clone().into()))
-        },
         AlgorithmIdentifier::Object(obj) => {
-            rooted!(in(*cx) let value = ObjectValue(unsafe { *obj.get_unsafe() }));
+            rooted!(in(*cx) let value = ObjectValue(obj.get()));
             let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle())
             else {
                 return Err(Error::Syntax);
             };
-            let normalized_name = algorithm.name.str().to_uppercase();
-
-            // This implements the table from https://w3c.github.io/webcrypto/#algorithm-overview
-            let normalized_algorithm = match (normalized_name.as_str(), operation) {
-                (ALG_AES_CBC, "encrypt") | (ALG_AES_CBC, "decrypt") => {
-                    let params_result =
-                        AesCbcParams::new(cx, value.handle()).map_err(|_| Error::Operation)?;
-                    let ConversionResult::Success(params) = params_result else {
-                        return Err(Error::Syntax);
-                    };
-                    NormalizedAlgorithm::AesCbcParams(params.into())
-                },
-                (ALG_AES_CTR, "encrypt") | (ALG_AES_CTR, "decrypt") => {
-                    let params_result =
-                        AesCtrParams::new(cx, value.handle()).map_err(|_| Error::Operation)?;
-                    let ConversionResult::Success(params) = params_result else {
-                        return Err(Error::Syntax);
-                    };
-                    NormalizedAlgorithm::AesCtrParams(params.into())
-                },
-                (ALG_AES_CBC, "generateKey") | (ALG_AES_CTR, "generateKey") => {
-                    let params_result =
-                        AesKeyGenParams::new(cx, value.handle()).map_err(|_| Error::Operation)?;
-                    let ConversionResult::Success(params) = params_result else {
-                        return Err(Error::Syntax);
-                    };
-                    NormalizedAlgorithm::AesKeyGenParams(params.into())
-                },
-                (ALG_ECDSA, "deriveBits") => NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
-                    name: ALG_ECDSA.to_string(),
-                }),
-                (ALG_HKDF, "deriveBits") => NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
-                    name: ALG_HKDF.to_string(),
-                }),
-                (ALG_PBKDF2, "deriveBits") => {
-                    let params_result =
-                        Pbkdf2Params::new(cx, value.handle()).map_err(|_| Error::Operation)?;
-                    let ConversionResult::Success(params) = params_result else {
-                        return Err(Error::Syntax);
-                    };
-                    let subtle_params = SubtlePbkdf2Params::new(cx, params)?;
-                    NormalizedAlgorithm::Pbkdf2Params(subtle_params)
-                },
-                (ALG_AES_CBC, "importKey") => NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
-                    name: ALG_AES_CBC.to_string(),
-                }),
-                (ALG_AES_CTR, "importKey") => NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
-                    name: ALG_AES_CTR.to_string(),
-                }),
-                (ALG_PBKDF2, "importKey") => NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
-                    name: ALG_PBKDF2.to_string(),
-                }),
-                (ALG_SHA1, "digest") => NormalizedAlgorithm::Sha1,
-                (ALG_SHA256, "digest") => NormalizedAlgorithm::Sha256,
-                (ALG_SHA384, "digest") => NormalizedAlgorithm::Sha384,
-                (ALG_SHA512, "digest") => NormalizedAlgorithm::Sha512,
-                _ => return Err(Error::NotSupported),
+
+            let name = algorithm.name.str();
+            let normalized_algorithm = if name.eq_ignore_ascii_case(ALG_AES_CBC) ||
+                name.eq_ignore_ascii_case(ALG_AES_CTR)
+            {
+                let params = value_from_js_object!(AesDerivedKeyParams, cx, value);
+                GetKeyLengthAlgorithm::Aes(params.length)
+            } else {
+                return Err(Error::NotSupported);
             };
 
             Ok(normalized_algorithm)
         },
+        AlgorithmIdentifier::String(_) => {
+            // All algorithms that support "get key length" require additional parameters
+            Err(Error::NotSupported)
+        },
     }
 }
 
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"digest"`
+fn normalize_algorithm_for_digest(
+    cx: JSContext,
+    algorithm: &AlgorithmIdentifier,
+) -> Result<DigestAlgorithm, Error> {
+    let name = match algorithm {
+        AlgorithmIdentifier::Object(obj) => {
+            rooted!(in(*cx) let value = ObjectValue(obj.get()));
+            let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle())
+            else {
+                return Err(Error::Syntax);
+            };
+
+            algorithm.name.str().to_uppercase()
+        },
+        AlgorithmIdentifier::String(name) => name.str().to_uppercase(),
+    };
+
+    let normalized_algorithm = match name.as_str() {
+        ALG_SHA1 => DigestAlgorithm::Sha1,
+        ALG_SHA256 => DigestAlgorithm::Sha256,
+        ALG_SHA384 => DigestAlgorithm::Sha384,
+        ALG_SHA512 => DigestAlgorithm::Sha512,
+        _ => return Err(Error::NotSupported),
+    };
+
+    Ok(normalized_algorithm)
+}
+
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"importKey"`
+fn normalize_algorithm_for_import_key(
+    cx: JSContext,
+    algorithm: &AlgorithmIdentifier,
+) -> Result<ImportKeyAlgorithm, Error> {
+    let name = match algorithm {
+        AlgorithmIdentifier::Object(obj) => {
+            rooted!(in(*cx) let value = ObjectValue(obj.get()));
+            let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle())
+            else {
+                return Err(Error::Syntax);
+            };
+
+            algorithm.name.str().to_uppercase()
+        },
+        AlgorithmIdentifier::String(name) => name.str().to_uppercase(),
+    };
+
+    let normalized_algorithm = match name.as_str() {
+        ALG_AES_CBC => ImportKeyAlgorithm::AesCbc,
+        ALG_AES_CTR => ImportKeyAlgorithm::AesCtr,
+        ALG_PBKDF2 => ImportKeyAlgorithm::Pbkdf2,
+        _ => return Err(Error::NotSupported),
+    };
+
+    Ok(normalized_algorithm)
+}
+
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"deriveBits"`
+fn normalize_algorithm_for_derive_bits(
+    cx: JSContext,
+    algorithm: &AlgorithmIdentifier,
+) -> Result<DeriveBitsAlgorithm, Error> {
+    let AlgorithmIdentifier::Object(obj) = algorithm else {
+        // All algorithms that support "deriveBits" require additional parameters
+        return Err(Error::NotSupported);
+    };
+
+    rooted!(in(*cx) let value = ObjectValue(obj.get()));
+    let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle()) else {
+        return Err(Error::Syntax);
+    };
+
+    let normalized_algorithm = if algorithm.name.str().eq_ignore_ascii_case(ALG_PBKDF2) {
+        let params = value_from_js_object!(Pbkdf2Params, cx, value);
+        let subtle_params = SubtlePbkdf2Params::new(cx, params)?;
+        DeriveBitsAlgorithm::Pbkdf2(subtle_params)
+    } else {
+        return Err(Error::NotSupported);
+    };
+
+    Ok(normalized_algorithm)
+}
+
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"deriveBits"`
+fn normalize_algorithm_for_encrypt_or_decrypt(
+    cx: JSContext,
+    algorithm: &AlgorithmIdentifier,
+) -> Result<EncryptionAlgorithm, Error> {
+    let AlgorithmIdentifier::Object(obj) = algorithm else {
+        // All algorithms that support "encrypt" or "decrypt" require additional parameters
+        return Err(Error::NotSupported);
+    };
+
+    rooted!(in(*cx) let value = ObjectValue(obj.get()));
+    let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle()) else {
+        return Err(Error::Syntax);
+    };
+
+    let name = algorithm.name.str();
+    let normalized_algorithm = if name.eq_ignore_ascii_case(ALG_AES_CBC) {
+        let params = value_from_js_object!(AesCbcParams, cx, value);
+        EncryptionAlgorithm::AesCbc(params.into())
+    } else if name.eq_ignore_ascii_case(ALG_AES_CTR) {
+        let params = value_from_js_object!(AesCtrParams, cx, value);
+        EncryptionAlgorithm::AesCtr(params.into())
+    } else {
+        return Err(Error::NotSupported);
+    };
+
+    Ok(normalized_algorithm)
+}
+
+/// <https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm> with operation `"generateKey"`
+fn normalize_algorithm_for_generate_key(
+    cx: JSContext,
+    algorithm: &AlgorithmIdentifier,
+) -> Result<KeyGenerationAlgorithm, Error> {
+    let AlgorithmIdentifier::Object(obj) = algorithm else {
+        // All algorithms that support "generateKey" require additional parameters
+        return Err(Error::NotSupported);
+    };
+
+    rooted!(in(*cx) let value = ObjectValue(obj.get()));
+    let Ok(ConversionResult::Success(algorithm)) = Algorithm::new(cx, value.handle()) else {
+        return Err(Error::Syntax);
+    };
+
+    let name = algorithm.name.str();
+    let normalized_algorithm =
+        if name.eq_ignore_ascii_case(ALG_AES_CBC) || name.eq_ignore_ascii_case(ALG_AES_CTR) {
+            let params = value_from_js_object!(AesKeyGenParams, cx, value);
+            KeyGenerationAlgorithm::Aes(params.into())
+        } else {
+            return Err(Error::NotSupported);
+        };
+
+    Ok(normalized_algorithm)
+}
+
 impl SubtleCrypto {
     /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
     fn encrypt_aes_cbc(
         &self,
-        params: SubtleAesCbcParams,
+        params: &SubtleAesCbcParams,
         key: &CryptoKey,
         data: &[u8],
         cx: JSContext,
@@ -966,7 +1064,7 @@ impl SubtleCrypto {
     /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
     fn decrypt_aes_cbc(
         &self,
-        params: SubtleAesCbcParams,
+        params: &SubtleAesCbcParams,
         key: &CryptoKey,
         data: &[u8],
         cx: JSContext,
@@ -1010,7 +1108,7 @@ impl SubtleCrypto {
     /// <https://w3c.github.io/webcrypto/#aes-ctr-operations>
     fn encrypt_decrypt_aes_ctr(
         &self,
-        params: SubtleAesCtrParams,
+        params: &SubtleAesCtrParams,
         key: &CryptoKey,
         data: &[u8],
         cx: JSContext,
@@ -1051,7 +1149,7 @@ impl SubtleCrypto {
     fn generate_key_aes(
         &self,
         usages: Vec<KeyUsage>,
-        key_gen_params: SubtleAesKeyGenParams,
+        key_gen_params: &SubtleAesKeyGenParams,
         extractable: bool,
     ) -> Result<DomRoot<CryptoKey>, Error> {
         let mut rand = vec![0; key_gen_params.length as usize];
@@ -1323,16 +1421,11 @@ impl SubtlePbkdf2Params {
 
         // Step 3. Let prf be the MAC Generation function described in Section 4 of [FIPS-198-1]
         // using the hash function described by the hash member of normalizedAlgorithm.
-        let NormalizedAlgorithm::Algorithm(alg) = &*self.hash else {
-            return Err(Error::NotSupported);
-        };
-
-        let prf = match alg.name.as_str() {
-            ALG_SHA1 => pbkdf2::PBKDF2_HMAC_SHA1,
-            ALG_SHA256 => pbkdf2::PBKDF2_HMAC_SHA256,
-            ALG_SHA384 => pbkdf2::PBKDF2_HMAC_SHA384,
-            ALG_SHA512 => pbkdf2::PBKDF2_HMAC_SHA512,
-            _ => return Err(Error::NotSupported),
+        let prf = match self.hash {
+            DigestAlgorithm::Sha1 => pbkdf2::PBKDF2_HMAC_SHA1,
+            DigestAlgorithm::Sha256 => pbkdf2::PBKDF2_HMAC_SHA256,
+            DigestAlgorithm::Sha384 => pbkdf2::PBKDF2_HMAC_SHA384,
+            DigestAlgorithm::Sha512 => pbkdf2::PBKDF2_HMAC_SHA512,
         };
 
         // Step 4. Let result be the result of performing the PBKDF2 operation defined in Section 5.2 of [RFC8018] using
@@ -1358,23 +1451,39 @@ impl SubtlePbkdf2Params {
     }
 }
 
-impl NormalizedAlgorithm {
-    fn derive_bits(&self, key: &CryptoKey, length: Option<u32>) -> Result<Vec<u8>, Error> {
-        match self {
-            Self::Pbkdf2Params(pbkdf2_params) => pbkdf2_params.derive_bits(key, length),
-            _ => Err(Error::NotSupported),
-        }
+/// <https://w3c.github.io/webcrypto/#aes-ctr-operations>
+fn get_key_length_for_aes(length: u16) -> Result<u16, Error> {
+    // Step 1. If the length member of normalizedDerivedKeyAlgorithm is not 128, 192 or 256,
+    // then throw an OperationError.
+    if !matches!(length, 128 | 192 | 256) {
+        return Err(Error::Operation);
     }
 
+    // Step 2. Return the length member of normalizedDerivedKeyAlgorithm.
+    Ok(length)
+}
+
+impl GetKeyLengthAlgorithm {
     fn get_key_length(&self) -> Result<u16, Error> {
         match self {
-            Self::AesCtrParams(aes_ctr_params) => {
-                get_key_length_for_aes(aes_ctr_params.length as u16)
-            },
-            _ => Err(Error::NotSupported),
+            Self::Aes(length) => get_key_length_for_aes(*length),
         }
     }
+}
 
+impl DigestAlgorithm {
+    fn digest(&self, data: &[u8]) -> Result<impl AsRef<[u8]>, Error> {
+        let algorithm = match self {
+            Self::Sha1 => &digest::SHA1_FOR_LEGACY_USE_ONLY,
+            Self::Sha256 => &digest::SHA256,
+            Self::Sha384 => &digest::SHA384,
+            Self::Sha512 => &digest::SHA512,
+        };
+        Ok(digest::digest(algorithm, data))
+    }
+}
+
+impl ImportKeyAlgorithm {
     fn import_key(
         &self,
         subtle: &SubtleCrypto,
@@ -1383,47 +1492,84 @@ impl NormalizedAlgorithm {
         extractable: bool,
         key_usages: Vec<KeyUsage>,
     ) -> Result<DomRoot<CryptoKey>, Error> {
-        let alg = match self {
-            Self::Algorithm(name) => name,
-            _ => {
-                return Err(Error::NotSupported);
-            },
-        };
-
-        match alg.name.as_str() {
-            ALG_AES_CBC => {
+        match self {
+            Self::AesCbc => {
                 subtle.import_key_aes(format, secret, extractable, key_usages, ALG_AES_CBC)
             },
-            ALG_AES_CTR => {
+            Self::AesCtr => {
                 subtle.import_key_aes(format, secret, extractable, key_usages, ALG_AES_CTR)
             },
-            ALG_PBKDF2 => subtle.import_key_pbkdf2(format, secret, extractable, key_usages),
-            _ => Err(Error::NotSupported),
+            Self::Pbkdf2 => subtle.import_key_pbkdf2(format, secret, extractable, key_usages),
         }
     }
+}
 
-    fn digest(&self, data: &[u8]) -> Result<impl AsRef<[u8]>, Error> {
-        let algorithm = match self {
-            Self::Sha1 => &digest::SHA1_FOR_LEGACY_USE_ONLY,
-            Self::Sha256 => &digest::SHA256,
-            Self::Sha384 => &digest::SHA384,
-            Self::Sha512 => &digest::SHA512,
-            _ => {
-                return Err(Error::NotSupported);
-            },
-        };
-        Ok(digest::digest(algorithm, data))
+impl DeriveBitsAlgorithm {
+    fn derive_bits(&self, key: &CryptoKey, length: Option<u32>) -> Result<Vec<u8>, Error> {
+        match self {
+            Self::Pbkdf2(pbkdf2_params) => pbkdf2_params.derive_bits(key, length),
+        }
     }
 }
 
-/// <https://w3c.github.io/webcrypto/#aes-ctr-operations>
-fn get_key_length_for_aes(length: u16) -> Result<u16, Error> {
-    // Step 1. If the length member of normalizedDerivedKeyAlgorithm is not 128, 192 or 256,
-    // then throw an OperationError.
-    if !matches!(length, 128 | 192 | 256) {
-        return Err(Error::Operation);
+impl EncryptionAlgorithm {
+    /// <https://w3c.github.io/webcrypto/#dom-algorithm-name>
+    fn name(&self) -> &str {
+        match self {
+            Self::AesCbc(key_gen_params) => &key_gen_params.name,
+            Self::AesCtr(key_gen_params) => &key_gen_params.name,
+        }
     }
 
-    // Step 2. Return the length member of normalizedDerivedKeyAlgorithm.
-    Ok(length)
+    // FIXME: This doesn't really need the "SubtleCrypto" argument
+    fn encrypt(
+        &self,
+        subtle: &SubtleCrypto,
+        key: &CryptoKey,
+        data: &[u8],
+        cx: JSContext,
+        result: MutableHandleObject,
+    ) -> Result<(), Error> {
+        match self {
+            Self::AesCbc(key_gen_params) => {
+                subtle.encrypt_aes_cbc(key_gen_params, key, data, cx, result)
+            },
+            Self::AesCtr(key_gen_params) => {
+                subtle.encrypt_decrypt_aes_ctr(key_gen_params, key, data, cx, result)
+            },
+        }
+    }
+
+    // FIXME: This doesn't really need the "SubtleCrypto" argument
+    fn decrypt(
+        &self,
+        subtle: &SubtleCrypto,
+        key: &CryptoKey,
+        data: &[u8],
+        cx: JSContext,
+        result: MutableHandleObject,
+    ) -> Result<(), Error> {
+        match self {
+            Self::AesCbc(key_gen_params) => {
+                subtle.decrypt_aes_cbc(key_gen_params, key, data, cx, result)
+            },
+            Self::AesCtr(key_gen_params) => {
+                subtle.encrypt_decrypt_aes_ctr(key_gen_params, key, data, cx, result)
+            },
+        }
+    }
+}
+
+impl KeyGenerationAlgorithm {
+    // FIXME: This doesn't really need the "SubtleCrypto" argument
+    fn generate_key(
+        &self,
+        subtle: &SubtleCrypto,
+        usages: Vec<KeyUsage>,
+        extractable: bool,
+    ) -> Result<DomRoot<CryptoKey>, Error> {
+        match self {
+            Self::Aes(params) => subtle.generate_key_aes(usages, params, extractable),
+        }
+    }
 }
diff --git a/tests/wpt/meta/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js.ini b/tests/wpt/meta/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js.ini
index 44bd69f503e..28d9fd2660a 100644
--- a/tests/wpt/meta/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js.ini
+++ b/tests/wpt/meta/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js.ini
@@ -29,57 +29,21 @@
   [long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -176,24 +140,6 @@
   [long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -224,57 +170,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -371,57 +281,21 @@
   [long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -518,57 +392,21 @@
   [long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -665,24 +503,6 @@
   [long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -713,57 +533,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -860,57 +644,21 @@
   [long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1007,57 +755,21 @@
   [long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1154,24 +866,6 @@
   [long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -1202,57 +896,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1349,57 +1007,21 @@
   [long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1496,57 +1118,21 @@
   [long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1643,24 +1229,6 @@
   [long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -1691,57 +1259,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1838,57 +1370,21 @@
   [long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -1985,57 +1481,21 @@
   [long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
 
 [pbkdf2.https.any.html?4001-5000]
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
@@ -2134,24 +1594,6 @@
   [long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -2182,57 +1624,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -2329,57 +1735,21 @@
   [long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -2476,57 +1846,21 @@
   [long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -2623,24 +1957,6 @@
   [long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -2671,57 +1987,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -2818,57 +2098,21 @@
   [long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -2965,57 +2209,21 @@
   [long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3112,24 +2320,6 @@
   [long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -3160,57 +2350,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3307,57 +2461,21 @@
   [long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3454,57 +2572,21 @@
   [long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3601,24 +2683,6 @@
   [long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -3649,57 +2713,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3796,57 +2824,21 @@
   [long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -3943,57 +2935,21 @@
   [long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4089,18 +3045,9 @@
 
 
 [pbkdf2.https.any.html?6001-7000]
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4197,57 +3144,21 @@
   [empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4344,57 +3255,21 @@
   [empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4491,24 +3366,6 @@
   [empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -4539,57 +3396,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4686,57 +3507,21 @@
   [empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4833,57 +3618,21 @@
   [empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -4980,24 +3729,6 @@
   [empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -5028,57 +3759,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5175,57 +3870,21 @@
   [empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5322,57 +3981,21 @@
   [empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5469,24 +4092,6 @@
   [empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -5517,57 +4122,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5664,57 +4233,21 @@
   [empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5811,57 +4344,21 @@
   [empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -5958,24 +4455,6 @@
   [empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -6006,57 +4485,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6143,30 +4586,12 @@
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6263,57 +4688,21 @@
   [short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6410,24 +4799,6 @@
   [short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -6458,57 +4829,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6605,57 +4940,21 @@
   [short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6752,57 +5051,21 @@
   [short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -6899,24 +5162,6 @@
   [short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -6947,57 +5192,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7094,57 +5303,21 @@
   [short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7241,57 +5414,21 @@
   [short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7388,24 +5525,6 @@
   [short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -7436,57 +5555,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7583,57 +5666,21 @@
   [short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7730,57 +5777,21 @@
   [short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -7877,24 +5888,6 @@
   [short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -7925,57 +5918,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8072,57 +6029,21 @@
   [long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8272,57 +6193,21 @@
   [empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8419,24 +6304,6 @@
   [empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -8467,57 +6334,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8614,57 +6445,21 @@
   [empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8761,57 +6556,21 @@
   [empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -8908,24 +6667,6 @@
   [empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -8956,57 +6697,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -9103,57 +6808,21 @@
   [empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -9250,57 +6919,21 @@
   [empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -9397,24 +7030,6 @@
   [empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -9543,24 +7158,6 @@
   [long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -9591,57 +7188,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -9738,57 +7299,21 @@
   [long password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -9885,57 +7410,21 @@
   [long password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10032,24 +7521,6 @@
   [long password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -10080,57 +7551,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10227,57 +7662,21 @@
   [long password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10374,57 +7773,21 @@
   [long password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10521,24 +7884,6 @@
   [long password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -10569,57 +7914,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10716,57 +8025,21 @@
   [long password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -10863,57 +8136,21 @@
   [long password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11010,24 +8247,6 @@
   [long password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -11058,57 +8277,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11205,57 +8388,21 @@
   [long password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11352,57 +8499,21 @@
   [long password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11498,18 +8609,9 @@
 
 
 [pbkdf2.https.any.worker.html?6001-7000]
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11606,57 +8708,21 @@
   [empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11753,57 +8819,21 @@
   [empty password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -11900,24 +8930,6 @@
   [empty password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -11948,57 +8960,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12095,57 +9071,21 @@
   [empty password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12242,57 +9182,21 @@
   [empty password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12389,24 +9293,6 @@
   [empty password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -12437,57 +9323,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12584,57 +9434,21 @@
   [empty password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12731,57 +9545,21 @@
   [empty password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -12878,24 +9656,6 @@
   [empty password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -12926,57 +9686,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13073,57 +9797,21 @@
   [empty password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13220,57 +9908,21 @@
   [empty password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13367,24 +10019,6 @@
   [empty password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -13415,57 +10049,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13606,57 +10204,21 @@
   [short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13753,57 +10315,21 @@
   [short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -13900,24 +10426,6 @@
   [short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -13948,57 +10456,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14095,57 +10567,21 @@
   [short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14242,57 +10678,21 @@
   [short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14389,24 +10789,6 @@
   [short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -14437,57 +10819,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14584,57 +10930,21 @@
   [short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14731,57 +11041,21 @@
   [short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -14878,24 +11152,6 @@
   [short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -14926,57 +11182,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15073,57 +11293,21 @@
   [short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15220,57 +11404,21 @@
   [short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15367,24 +11515,6 @@
   [short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -15415,57 +11545,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15562,30 +11656,12 @@
   [short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
 
 [pbkdf2.https.any.html?1001-2000]
   [Derived key of type name: AES-KW length: 192  using short password, long salt, SHA-384, with 1 iterations]
@@ -15645,57 +11721,21 @@
   [short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15792,57 +11832,21 @@
   [short password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -15939,24 +11943,6 @@
   [short password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -15987,57 +11973,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16134,57 +12084,21 @@
   [short password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16281,57 +12195,21 @@
   [short password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16428,24 +12306,6 @@
   [short password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -16476,57 +12336,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16623,57 +12447,21 @@
   [short password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16770,57 +12558,21 @@
   [short password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -16917,24 +12669,6 @@
   [short password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -16965,57 +12699,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17112,57 +12810,21 @@
   [short password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17259,57 +12921,21 @@
   [short password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17406,24 +13032,6 @@
   [short password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -17454,57 +13062,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17601,53 +13173,17 @@
   [short password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
 
 [pbkdf2.https.any.worker.html?5001-6000]
   [long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -17678,57 +13214,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17825,57 +13325,21 @@
   [long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -17972,57 +13436,21 @@
   [long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18119,24 +13547,6 @@
   [long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -18167,57 +13577,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18314,57 +13688,21 @@
   [long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18461,57 +13799,21 @@
   [long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18608,24 +13910,6 @@
   [long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -18656,57 +13940,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18803,57 +14051,21 @@
   [long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -18950,57 +14162,21 @@
   [long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19097,24 +14273,6 @@
   [long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -19145,57 +14303,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19292,57 +14414,21 @@
   [empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19439,57 +14525,21 @@
   [empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19586,24 +14636,6 @@
   [empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -19634,98 +14666,35 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
 
 [pbkdf2.https.any.html?1-1000]
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19822,57 +14791,21 @@
   [short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -19969,57 +14902,21 @@
   [short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20116,24 +15013,6 @@
   [short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -20164,57 +15043,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20311,57 +15154,21 @@
   [short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20458,57 +15265,21 @@
   [short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20605,24 +15376,6 @@
   [short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -20653,57 +15406,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20800,57 +15517,21 @@
   [short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -20947,57 +15628,21 @@
   [short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21094,24 +15739,6 @@
   [short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -21142,57 +15769,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21289,57 +15880,21 @@
   [short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21436,57 +15991,21 @@
   [short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21583,24 +16102,6 @@
   [short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -21631,57 +16132,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21738,57 +16203,21 @@
   [empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -21885,57 +16314,21 @@
   [empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22032,24 +16425,6 @@
   [empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -22080,57 +16455,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22227,57 +16566,21 @@
   [empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22374,57 +16677,21 @@
   [empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22521,24 +16788,6 @@
   [empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -22569,57 +16818,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22716,57 +16929,21 @@
   [empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -22863,57 +17040,21 @@
   [empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23010,24 +17151,6 @@
   [empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -23058,57 +17181,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23205,57 +17292,21 @@
   [empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23352,57 +17403,21 @@
   [empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23499,24 +17514,6 @@
   [empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -23547,57 +17544,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23694,57 +17655,21 @@
   [empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23777,57 +17702,21 @@
   [empty password, long salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -23924,57 +17813,21 @@
   [empty password, long salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24071,24 +17924,6 @@
   [empty password, long salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -24119,57 +17954,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24266,57 +18065,21 @@
   [empty password, long salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24413,57 +18176,21 @@
   [empty password, long salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24560,24 +18287,6 @@
   [empty password, long salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -24608,57 +18317,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24755,57 +18428,21 @@
   [empty password, long salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -24902,57 +18539,21 @@
   [empty password, long salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25049,24 +18650,6 @@
   [empty password, long salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, long salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -25097,57 +18680,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, long salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25244,57 +18791,21 @@
   [empty password, empty salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25391,57 +18902,21 @@
   [empty password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25538,24 +19013,6 @@
   [empty password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -25586,57 +19043,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25733,57 +19154,21 @@
   [empty password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25831,57 +19216,21 @@
   [long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -25978,24 +19327,6 @@
   [long password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -26026,57 +19357,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26173,57 +19468,21 @@
   [long password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26320,57 +19579,21 @@
   [long password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26467,24 +19690,6 @@
   [long password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -26515,57 +19720,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26662,57 +19831,21 @@
   [long password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26809,57 +19942,21 @@
   [long password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -26956,24 +20053,6 @@
   [long password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -27004,57 +20083,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27151,57 +20194,21 @@
   [long password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27298,57 +20305,21 @@
   [long password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27445,24 +20416,6 @@
   [long password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -27493,57 +20446,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27640,57 +20557,21 @@
   [long password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27787,86 +20668,32 @@
   [long password, long salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, long salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, long salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
 
 [pbkdf2.https.any.html?2001-3000]
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -27963,57 +20790,21 @@
   [short password, empty salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28110,24 +20901,6 @@
   [short password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -28158,57 +20931,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28305,57 +21042,21 @@
   [short password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28452,57 +21153,21 @@
   [short password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28599,24 +21264,6 @@
   [short password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -28647,57 +21294,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28794,57 +21405,21 @@
   [short password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -28941,57 +21516,21 @@
   [short password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29088,24 +21627,6 @@
   [short password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -29136,57 +21657,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29283,57 +21768,21 @@
   [short password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29430,57 +21879,21 @@
   [short password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29577,24 +21990,6 @@
   [short password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -29625,57 +22020,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29772,57 +22131,21 @@
   [long password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -29972,57 +22295,21 @@
   [empty password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30119,24 +22406,6 @@
   [empty password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -30167,57 +22436,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30314,57 +22547,21 @@
   [empty password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30461,57 +22658,21 @@
   [empty password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30608,24 +22769,6 @@
   [empty password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -30656,57 +22799,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30803,57 +22910,21 @@
   [empty password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -30950,57 +23021,21 @@
   [empty password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31097,24 +23132,6 @@
   [empty password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -31150,24 +23167,6 @@
   [long password, empty salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -31198,57 +23197,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31345,57 +23308,21 @@
   [long password, empty salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31492,57 +23419,21 @@
   [long password, empty salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31639,24 +23530,6 @@
   [long password, empty salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -31687,57 +23560,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31834,57 +23671,21 @@
   [long password, empty salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -31981,57 +23782,21 @@
   [long password, empty salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32128,24 +23893,6 @@
   [long password, empty salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -32176,57 +23923,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32323,57 +24034,21 @@
   [long password, empty salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32470,57 +24145,21 @@
   [long password, empty salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32617,24 +24256,6 @@
   [long password, empty salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using long password, empty salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using long password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -32665,57 +24286,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using long password, empty salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32812,57 +24397,21 @@
   [empty password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -32959,57 +24508,21 @@
   [empty password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33106,24 +24619,6 @@
   [empty password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using empty password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using empty password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -33154,98 +24649,35 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using empty password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using empty password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using empty password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
 
 [pbkdf2.https.any.worker.html?1-1000]
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33342,57 +24774,21 @@
   [short password, short salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33489,57 +24885,21 @@
   [short password, short salt, SHA-384, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33636,24 +24996,6 @@
   [short password, short salt, SHA-384, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-384, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
@@ -33684,57 +25026,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-384, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33831,57 +25137,21 @@
   [short password, short salt, SHA-512, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -33978,57 +25248,21 @@
   [short password, short salt, SHA-512, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34125,24 +25359,6 @@
   [short password, short salt, SHA-512, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-512, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
@@ -34173,57 +25389,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-512, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34320,57 +25500,21 @@
   [short password, short salt, SHA-1, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34467,57 +25611,21 @@
   [short password, short salt, SHA-1, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34614,24 +25722,6 @@
   [short password, short salt, SHA-1, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-1, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
@@ -34662,57 +25752,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-1, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34809,57 +25863,21 @@
   [short password, short salt, SHA-256, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -34956,57 +25974,21 @@
   [short password, short salt, SHA-256, with 1000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
@@ -35103,24 +26085,6 @@
   [short password, short salt, SHA-256, with 100000 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, short salt, SHA-256, with 0 iterations]
-    expected: FAIL
-
   [Derived key of type name: AES-GCM length: 128  using short password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
@@ -35151,57 +26115,21 @@
   [Derived key of type name: HMAC hash: SHA-512 length: 256  using short password, short salt, SHA-256, with 0 iterations]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 128  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 192  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CBC length: 256  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 128  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 192  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations]
-    expected: FAIL
-
-  [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations with missing deriveKey usage]
-    expected: FAIL
-
   [Derived key of type name: AES-CTR length: 256  using short password, long salt, SHA-384, with 1 iterations with wrong (ECDH) key]
     expected: FAIL
 
diff --git a/tests/wpt/meta/fetch/content-encoding/br/big-br-body.https.any.js.ini b/tests/wpt/meta/fetch/content-encoding/br/big-br-body.https.any.js.ini
index 56cd175f48b..79158924072 100644
--- a/tests/wpt/meta/fetch/content-encoding/br/big-br-body.https.any.js.ini
+++ b/tests/wpt/meta/fetch/content-encoding/br/big-br-body.https.any.js.ini
@@ -2,17 +2,11 @@
   expected: ERROR
 
 [big-br-body.https.any.html]
-  [large br data should be decompressed successfully]
-    expected: FAIL
-
   [large br data should be decompressed successfully with byte stream]
     expected: FAIL
 
 
 [big-br-body.https.any.worker.html]
-  [large br data should be decompressed successfully]
-    expected: FAIL
-
   [large br data should be decompressed successfully with byte stream]
     expected: FAIL
 
diff --git a/tests/wpt/meta/fetch/content-encoding/gzip/big-gzip-body.https.any.js.ini b/tests/wpt/meta/fetch/content-encoding/gzip/big-gzip-body.https.any.js.ini
index 625d6f9c017..032d354ce05 100644
--- a/tests/wpt/meta/fetch/content-encoding/gzip/big-gzip-body.https.any.js.ini
+++ b/tests/wpt/meta/fetch/content-encoding/gzip/big-gzip-body.https.any.js.ini
@@ -2,17 +2,11 @@
   expected: ERROR
 
 [big-gzip-body.https.any.worker.html]
-  [large gzip data should be decompressed successfully]
-    expected: FAIL
-
   [large gzip data should be decompressed successfully with byte stream]
     expected: FAIL
 
 
 [big-gzip-body.https.any.html]
-  [large gzip data should be decompressed successfully]
-    expected: FAIL
-
   [large gzip data should be decompressed successfully with byte stream]
     expected: FAIL