crypto: Implement encrypt/decrypt for AES-CBC + JWK support (#33795)

* Add support for raw importKey with AES-CBC

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Support JWK import/export, importKey for AES-CBC

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Implement encrypt/decrypt for AES-CBC

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Update expectations

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Update Cargo.lock

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Pass MutableHandleObject as arg instead of returning raw pointer

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Swap order of checks in generate_key_aes_cbc

- Fixes WPT tests that expect to error on algorithm first before usages

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Avoid potential GC hazard with array_buffer_ptr

Signed-off-by: Daniel Adams <msub2official@gmail.com>

* Update expectations for discards context

Signed-off-by: Daniel Adams <msub2official@gmail.com>

---------

Signed-off-by: Daniel Adams <msub2official@gmail.com>

Cargo.lock

@@ -470,6 +470,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -717,6 +726,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
 version = "1.1.31"
@@ -3667,6 +3685,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
 dependencies = [
+ "block-padding",
  "generic-array",
 ]
 
@@ -6039,7 +6058,9 @@ dependencies = [
  "bitflags 2.6.0",
  "bluetooth_traits",
  "canvas_traits",
+ "cbc",
  "chrono",
+ "cipher",
  "content-security-policy",
  "cookie 0.18.1",
  "crossbeam-channel",

Cargo.toml

@@ -32,6 +32,8 @@ bitflags = "2.6"
 bluetooth_traits = { path = "components/shared/bluetooth" }
 byteorder = "1.5"
 canvas_traits = { path = "components/shared/canvas" }
+cbc = "0.1.2"
+cipher = { version = "0.4.4", features = ["alloc"] }
 cfg-if = "1.0.0"
 chrono = { version = "0.4", features = ["serde"] }
 compositing_traits = { path = "components/shared/compositing" }

components/script/Cargo.toml

@@ -39,6 +39,8 @@ bincode = { workspace = true }
 bitflags = { workspace = true }
 bluetooth_traits = { workspace = true }
 canvas_traits = { workspace = true }
+cbc = { workspace = true }
+cipher = { workspace = true }
 chrono = { workspace = true }
 content-security-policy = { workspace = true }
 cookie = { workspace = true }

components/script/dom/bindings/codegen/Bindings.conf

@@ -281,6 +281,10 @@ DOMInterfaces = {
     'weakReferenceable': True,
 },
 
+'SubtleCrypto': {
+    'inRealms': ['Encrypt', 'Decrypt', 'GenerateKey', 'ImportKey', 'ExportKey']
+},
+
 #FIXME(jdm): This should be 'register': False, but then we don't generate enum types
 'TestBinding': {
     'inRealms': ['PromiseAttribute', 'PromiseNativeHandler'],
@@ -323,31 +327,10 @@ DOMInterfaces = {
     'canGc': ['Abort', 'GetResponseXML', 'Response'],
 },
 
-'XRSession': {
-    'inRealms': ['RequestReferenceSpace', 'UpdateRenderState', 'UpdateTargetFrameRate'],
-    'canGc': ['End', 'RequestReferenceSpace'],
-},
-
-'XRSystem': {
-    'inRealms': ['RequestSession', 'SupportsSessionMode'],
-},
-
 'XRBoundedReferenceSpace': {
     'canGc': ['BoundsGeometry'],
 },
 
-'XRRay': {
-    'canGc': ['Origin', 'Direction'],
-},
-
-'XRRigidTransform': {
-    'canGc': ['Position', 'Orientation', 'Inverse'],
-},
-
-'XRReferenceSpace': {
-    'canGc': ['GetOffsetReferenceSpace'],
-},
-
 'XRFrame': {
     'canGc': ['GetViewerPose', 'GetPose', 'GetJointPose'],
 },
@@ -356,8 +339,25 @@ DOMInterfaces = {
     'canGc': ['GetPose'],
 },
 
-'SubtleCrypto': {
+'XRRay': {
-    'inRealms': ['GenerateKey', 'ExportKey']
+    'canGc': ['Origin', 'Direction'],
-}
+},
+
+'XRReferenceSpace': {
+    'canGc': ['GetOffsetReferenceSpace'],
+},
+
+'XRRigidTransform': {
+    'canGc': ['Position', 'Orientation', 'Inverse'],
+},
+
+'XRSession': {
+    'inRealms': ['RequestReferenceSpace', 'UpdateRenderState', 'UpdateTargetFrameRate'],
+    'canGc': ['End', 'RequestReferenceSpace'],
+},
+
+'XRSystem': {
+    'inRealms': ['RequestSession', 'SupportsSessionMode'],
+},
 
 }

components/script/dom/bindings/error.rs

@@ -85,6 +85,8 @@ pub enum Error {
     InvalidModification,
     /// NotReadableError DOMException
     NotReadable,
+    /// DataError DOMException
+    Data,
     /// OperationError DOMException
     Operation,
 
@@ -139,6 +141,7 @@ pub fn throw_dom_exception(cx: SafeJSContext, global: &GlobalScope, result: Erro
         Error::TypeMismatch => DOMErrorName::TypeMismatchError,
         Error::InvalidModification => DOMErrorName::InvalidModificationError,
         Error::NotReadable => DOMErrorName::NotReadableError,
+        Error::Data => DOMErrorName::DataError,
         Error::Operation => DOMErrorName::OperationError,
         Error::Type(message) => unsafe {
             assert!(!JS_IsExceptionPending(*cx));

components/script/dom/cryptokey.rs

@@ -85,6 +85,10 @@ impl CryptoKey {
         self.algorithm.borrow().to_string()
     }
 
+    pub fn usages(&self) -> &[KeyUsage] {
+        &self.usages
+    }
+
     pub fn handle(&self) -> &Handle {
         &self.handle
     }

components/script/dom/domexception.rs

@@ -45,6 +45,7 @@ pub enum DOMErrorName {
     DataCloneError = DOMExceptionConstants::DATA_CLONE_ERR,
     EncodingError,
     NotReadableError,
+    DataError,
     OperationError,
 }
 
@@ -75,6 +76,7 @@ impl DOMErrorName {
             "DataCloneError" => Some(DOMErrorName::DataCloneError),
             "EncodingError" => Some(DOMErrorName::EncodingError),
             "NotReadableError" => Some(DOMErrorName::NotReadableError),
+            "DataError" => Some(DOMErrorName::DataError),
             "OperationError" => Some(DOMErrorName::OperationError),
             _ => None,
         }
@@ -123,6 +125,7 @@ impl DOMException {
                 "The encoding operation (either encoded or decoding) failed."
             },
             DOMErrorName::NotReadableError => "The I/O read operation failed.",
+            DOMErrorName::DataError => "Provided data is inadequate.",
             DOMErrorName::OperationError => {
                 "The operation failed for an operation-specific reason."
             },

components/script/dom/subtlecrypto.rs

@@ -5,10 +5,16 @@
 use std::ptr;
 use std::rc::Rc;
 
+use aes::cipher::block_padding::Pkcs7;
+use aes::cipher::generic_array::GenericArray;
+use aes::cipher::{BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use aes::{Aes128, Aes192, Aes256};
+use base64::prelude::*;
 use dom_struct::dom_struct;
 use js::conversions::ConversionResult;
 use js::jsapi::JSObject;
 use js::jsval::ObjectValue;
+use js::rust::MutableHandleObject;
 use js::typedarray::ArrayBufferU8;
 use servo_rand::{RngCore, ServoRng};
 
@@ -18,7 +24,11 @@ use crate::dom::bindings::codegen::Bindings::CryptoKeyBinding::{
     CryptoKeyMethods, KeyType, KeyUsage,
 };
 use crate::dom::bindings::codegen::Bindings::SubtleCryptoBinding::{
-    AesKeyGenParams, Algorithm, AlgorithmIdentifier, KeyAlgorithm, KeyFormat, SubtleCryptoMethods,
+    AesCbcParams, AesKeyGenParams, Algorithm, AlgorithmIdentifier, JsonWebKey, KeyAlgorithm,
+    KeyFormat, SubtleCryptoMethods,
+};
+use crate::dom::bindings::codegen::UnionTypes::{
+    ArrayBufferViewOrArrayBuffer, ArrayBufferViewOrArrayBufferOrJsonWebKey,
 };
 use crate::dom::bindings::error::Error;
 use crate::dom::bindings::inheritance::Castable;
@@ -26,6 +36,7 @@ use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
 use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
+use crate::dom::bindings::trace::RootedTraceableBox;
 use crate::dom::cryptokey::{CryptoKey, Handle};
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
@@ -80,6 +91,13 @@ const NAMED_CURVE_P521: &str = "P-521";
 #[allow(dead_code)]
 static SUPPORTED_CURVES: &[&str] = &[NAMED_CURVE_P256, NAMED_CURVE_P384, NAMED_CURVE_P521];
 
+type Aes128CbcEnc = cbc::Encryptor<Aes128>;
+type Aes128CbcDec = cbc::Decryptor<Aes128>;
+type Aes192CbcEnc = cbc::Encryptor<Aes192>;
+type Aes192CbcDec = cbc::Decryptor<Aes192>;
+type Aes256CbcEnc = cbc::Encryptor<Aes256>;
+type Aes256CbcDec = cbc::Decryptor<Aes256>;
+
 #[dom_struct]
 pub struct SubtleCrypto {
     reflector_: Reflector,
@@ -115,6 +133,118 @@ impl SubtleCrypto {
 }
 
 impl SubtleCryptoMethods for SubtleCrypto {
+    /// <https://w3c.github.io/webcrypto/#SubtleCrypto-method-encrypt>
+    fn Encrypt(
+        &self,
+        cx: JSContext,
+        algorithm: AlgorithmIdentifier,
+        key: &CryptoKey,
+        data: ArrayBufferViewOrArrayBuffer,
+        comp: InRealm,
+    ) -> Rc<Promise> {
+        let normalized_algorithm = normalize_algorithm(cx, algorithm, "encrypt");
+        let promise = Promise::new_in_current_realm(comp);
+        let data = match data {
+            ArrayBufferViewOrArrayBuffer::ArrayBufferView(view) => view.to_vec(),
+            ArrayBufferViewOrArrayBuffer::ArrayBuffer(buffer) => buffer.to_vec(),
+        };
+
+        let (task_source, canceller) = self.task_source_with_canceller();
+        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(
+            task!(encrypt: move || {
+                let subtle = this.root();
+                let promise = trusted_promise.root();
+                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.encrypt_aes_cbc(
+                                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),
+                }
+            }),
+            &canceller,
+        );
+
+        promise
+    }
+
+    /// <https://w3c.github.io/webcrypto/#SubtleCrypto-method-decrypt>
+    fn Decrypt(
+        &self,
+        cx: JSContext,
+        algorithm: AlgorithmIdentifier,
+        key: &CryptoKey,
+        data: ArrayBufferViewOrArrayBuffer,
+        comp: InRealm,
+    ) -> Rc<Promise> {
+        let normalized_algorithm = normalize_algorithm(cx, algorithm, "decrypt");
+        let promise = Promise::new_in_current_realm(comp);
+        let data = match data {
+            ArrayBufferViewOrArrayBuffer::ArrayBufferView(view) => view.to_vec(),
+            ArrayBufferViewOrArrayBuffer::ArrayBuffer(buffer) => buffer.to_vec(),
+        };
+
+        let (task_source, canceller) = self.task_source_with_canceller();
+        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(
+            task!(decrypt: move || {
+                let subtle = this.root();
+                let promise = trusted_promise.root();
+                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),
+                            }
+                        }
+                    },
+                    _ => Err(Error::NotSupported),
+                };
+                match text {
+                    Ok(text) => promise.resolve_native(&*text),
+                    Err(e) => promise.reject_error(e),
+                }
+            }),
+            &canceller,
+        );
+
+        promise
+    }
+
     /// <https://w3c.github.io/webcrypto/#SubtleCrypto-method-generateKey>
     fn GenerateKey(
         &self,
@@ -156,8 +286,80 @@ impl SubtleCryptoMethods for SubtleCrypto {
         promise
     }
 
+    /// <https://w3c.github.io/webcrypto/#SubtleCrypto-method-importKey>
+    fn ImportKey(
+        &self,
+        cx: JSContext,
+        format: KeyFormat,
+        key_data: ArrayBufferViewOrArrayBufferOrJsonWebKey,
+        algorithm: AlgorithmIdentifier,
+        extractable: bool,
+        key_usages: Vec<KeyUsage>,
+        comp: InRealm,
+    ) -> Rc<Promise> {
+        let normalized_algorithm = normalize_algorithm(cx, algorithm, "importKey");
+        let promise = Promise::new_in_current_realm(comp);
+        if let Err(e) = normalized_algorithm {
+            promise.reject_error(e);
+            return promise;
+        }
+
+        // TODO: Figure out a way to Send this data so per-algorithm JWK checks can happen
+        let data = match key_data {
+            ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBufferView(view) => view.to_vec(),
+            ArrayBufferViewOrArrayBufferOrJsonWebKey::JsonWebKey(json_web_key) => {
+                if let Some(mut data_string) = json_web_key.k {
+                    while data_string.len() % 4 != 0 {
+                        data_string.push_str("=");
+                    }
+                    match BASE64_STANDARD.decode(data_string.to_string()) {
+                        Ok(data) => data,
+                        Err(_) => {
+                            promise.reject_error(Error::Syntax);
+                            return promise;
+                        },
+                    }
+                } else {
+                    promise.reject_error(Error::Syntax);
+                    return promise;
+                }
+            },
+            ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBuffer(array_buffer) => {
+                array_buffer.to_vec()
+            },
+        };
+
+        let (task_source, canceller) = self.task_source_with_canceller();
+        let this = Trusted::new(self);
+        let trusted_promise = TrustedPromise::new(promise.clone());
+        let _ = task_source.queue_with_canceller(
+            task!(import_key: move || {
+                let subtle = this.root();
+                let promise = trusted_promise.root();
+                let alg = match normalized_algorithm {
+                    Ok(NormalizedAlgorithm::Algorithm(name)) => name,
+                    _ => {
+                        promise.reject_error(Error::NotSupported);
+                        return;
+                    },
+                };
+
+                let imported_key = match alg.name.as_str() {
+                    ALG_AES_CBC => subtle.import_key_aes_cbc(format, &data, extractable, key_usages),
+                    _ => Err(Error::NotSupported),
+                };
+                match imported_key {
+                    Ok(k) => promise.resolve_native(&k),
+                    Err(e) => promise.reject_error(e),
+                };
+            }),
+            &canceller,
+        );
+
+        promise
+    }
+
     /// <https://w3c.github.io/webcrypto/#SubtleCrypto-method-exportKey>
-    #[allow(unsafe_code)]
     fn ExportKey(&self, format: KeyFormat, key: &CryptoKey, comp: InRealm) -> Rc<Promise> {
         let promise = Promise::new_in_current_realm(comp);
 
@@ -187,12 +389,19 @@ impl SubtleCryptoMethods for SubtleCrypto {
                 };
                 match exported_key {
                     Ok(k) => {
+                        match k {
+                            AesExportedKey::Raw(k) => {
                                 let cx = GlobalScope::get_cx();
                                 rooted!(in(*cx) let mut array_buffer_ptr = ptr::null_mut::<JSObject>());
                                 create_buffer_source::<ArrayBufferU8>(cx, &k, array_buffer_ptr.handle_mut())
                                     .expect("failed to create buffer source for exported key.");
                                 promise.resolve_native(&array_buffer_ptr.get())
                             },
+                            AesExportedKey::Jwk(k) => {
+                                promise.resolve_native(&k)
+                            },
+                        }
+                    },
                     Err(e) => promise.reject_error(e),
                 }
             }),
@@ -207,6 +416,7 @@ impl SubtleCryptoMethods for SubtleCrypto {
 pub enum NormalizedAlgorithm {
     #[allow(dead_code)]
     Algorithm(SubtleAlgorithm),
+    AesCbcParams(SubtleAesCbcParams),
     AesKeyGenParams(SubtleAesKeyGenParams),
 }
 
@@ -227,6 +437,26 @@ impl From<DOMString> for SubtleAlgorithm {
     }
 }
 
+#[derive(Clone)]
+pub struct SubtleAesCbcParams {
+    #[allow(dead_code)]
+    pub name: String,
+    pub iv: Vec<u8>,
+}
+
+impl From<RootedTraceableBox<AesCbcParams>> for SubtleAesCbcParams {
+    fn from(params: RootedTraceableBox<AesCbcParams>) -> Self {
+        let iv = match &params.iv {
+            ArrayBufferViewOrArrayBuffer::ArrayBufferView(view) => view.to_vec(),
+            ArrayBufferViewOrArrayBuffer::ArrayBuffer(buffer) => buffer.to_vec(),
+        };
+        SubtleAesCbcParams {
+            name: params.parent.name.to_string(),
+            iv,
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct SubtleAesKeyGenParams {
     #[allow(dead_code)]
@@ -259,6 +489,14 @@ fn normalize_algorithm(
                 return Err(Error::Syntax);
             };
             match (algorithm.name.str().to_uppercase().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);
+                    };
+                    Ok(NormalizedAlgorithm::AesCbcParams(params.into()))
+                },
                 (ALG_AES_CBC, "generateKey") => {
                     let params_result =
                         AesKeyGenParams::new(cx, value.handle()).map_err(|_| Error::Operation)?;
@@ -267,13 +505,96 @@ fn normalize_algorithm(
                     };
                     Ok(NormalizedAlgorithm::AesKeyGenParams(params.into()))
                 },
-                _ => Err(Error::NotSupported),
+                (ALG_AES_CBC, "importKey") => Ok(NormalizedAlgorithm::Algorithm(SubtleAlgorithm {
+                    name: ALG_AES_CBC.to_string(),
+                })),
+                _ => return Err(Error::NotSupported),
             }
         },
     }
 }
 
 impl SubtleCrypto {
+    /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
+    fn encrypt_aes_cbc(
+        &self,
+        params: SubtleAesCbcParams,
+        key: &CryptoKey,
+        data: &[u8],
+        cx: JSContext,
+        handle: MutableHandleObject,
+    ) -> Result<(), Error> {
+        if params.iv.len() != 16 {
+            return Err(Error::Operation);
+        }
+
+        let mut plaintext = Vec::from(data);
+        let iv = GenericArray::from_slice(&params.iv);
+
+        let ct = match key.handle() {
+            Handle::Aes128(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes128CbcEnc::new(key_data, iv).encrypt_padded_vec_mut::<Pkcs7>(&mut plaintext)
+            },
+            Handle::Aes192(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes192CbcEnc::new(key_data, iv).encrypt_padded_vec_mut::<Pkcs7>(&mut plaintext)
+            },
+            Handle::Aes256(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes256CbcEnc::new(key_data, iv).encrypt_padded_vec_mut::<Pkcs7>(&mut plaintext)
+            },
+        };
+
+        create_buffer_source::<ArrayBufferU8>(cx, &ct, handle)
+            .expect("failed to create buffer source for exported key.");
+
+        Ok(())
+    }
+
+    /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
+    fn decrypt_aes_cbc(
+        &self,
+        params: SubtleAesCbcParams,
+        key: &CryptoKey,
+        data: &[u8],
+        cx: JSContext,
+        handle: MutableHandleObject,
+    ) -> Result<(), Error> {
+        if params.iv.len() != 16 {
+            return Err(Error::Operation);
+        }
+
+        let mut ciphertext = Vec::from(data);
+        let iv = GenericArray::from_slice(&params.iv);
+
+        let plaintext = match key.handle() {
+            Handle::Aes128(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes128CbcDec::new(key_data, iv)
+                    .decrypt_padded_mut::<Pkcs7>(ciphertext.as_mut_slice())
+                    .map_err(|_| Error::Operation)?
+            },
+            Handle::Aes192(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes192CbcDec::new(key_data, iv)
+                    .decrypt_padded_mut::<Pkcs7>(ciphertext.as_mut_slice())
+                    .map_err(|_| Error::Operation)?
+            },
+            Handle::Aes256(data) => {
+                let key_data = GenericArray::from_slice(&data);
+                Aes256CbcDec::new(key_data, iv)
+                    .decrypt_padded_mut::<Pkcs7>(ciphertext.as_mut_slice())
+                    .map_err(|_| Error::Operation)?
+            },
+        };
+
+        create_buffer_source::<ArrayBufferU8>(cx, plaintext, handle)
+            .expect("failed to create buffer source for exported key.");
+
+        Ok(())
+    }
+
     /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
     fn generate_key_aes_cbc(
         &self,
@@ -281,9 +602,14 @@ impl SubtleCrypto {
         key_gen_params: SubtleAesKeyGenParams,
         extractable: bool,
     ) -> Result<DomRoot<CryptoKey>, Error> {
-        if !matches!(key_gen_params.length, 128 | 192 | 256) {
+        let mut rand = vec![0; key_gen_params.length as usize];
-            return Err(Error::Operation);
+        self.rng.borrow_mut().fill_bytes(&mut rand);
-        }
+        let handle = match key_gen_params.length {
+            128 => Handle::Aes128(rand),
+            192 => Handle::Aes192(rand),
+            256 => Handle::Aes256(rand),
+            _ => return Err(Error::Operation),
+        };
 
         if usages.iter().any(|usage| {
             !matches!(
@@ -295,15 +621,6 @@ impl SubtleCrypto {
             return Err(Error::Syntax);
         }
 
-        let mut rand = vec![0; key_gen_params.length as usize];
-        self.rng.borrow_mut().fill_bytes(&mut rand);
-        let handle = match key_gen_params.length {
-            128 => Handle::Aes128(rand),
-            192 => Handle::Aes192(rand),
-            256 => Handle::Aes256(rand),
-            _ => return Err(Error::Operation),
-        };
-
         Ok(CryptoKey::new(
             &self.global(),
             KeyType::Secret,
@@ -317,18 +634,95 @@ impl SubtleCrypto {
     }
 
     /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
-    fn export_key_aes_cbc(&self, format: KeyFormat, key: &CryptoKey) -> Result<Vec<u8>, Error> {
+    fn import_key_aes_cbc(
+        &self,
+        format: KeyFormat,
+        data: &[u8],
+        extractable: bool,
+        usages: Vec<KeyUsage>,
+    ) -> Result<DomRoot<CryptoKey>, Error> {
+        if usages.iter().any(|usage| {
+            !matches!(
+                usage,
+                KeyUsage::Encrypt | KeyUsage::Decrypt | KeyUsage::WrapKey | KeyUsage::UnwrapKey
+            )
+        }) || usages.is_empty()
+        {
+            return Err(Error::Syntax);
+        }
+        if !matches!(format, KeyFormat::Raw | KeyFormat::Jwk) {
+            return Err(Error::NotSupported);
+        }
+        let handle = match data.len() * 8 {
+            128 => Handle::Aes128(data.to_vec()),
+            192 => Handle::Aes192(data.to_vec()),
+            256 => Handle::Aes256(data.to_vec()),
+            _ => return Err(Error::Data),
+        };
+        Ok(CryptoKey::new(
+            &self.global(),
+            KeyType::Secret,
+            extractable,
+            KeyAlgorithm {
+                name: DOMString::from(ALG_AES_CBC),
+            },
+            usages,
+            handle,
+        ))
+    }
+
+    /// <https://w3c.github.io/webcrypto/#aes-cbc-operations>
+    fn export_key_aes_cbc(
+        &self,
+        format: KeyFormat,
+        key: &CryptoKey,
+    ) -> Result<AesExportedKey, Error> {
         match format {
             KeyFormat::Raw => match key.handle() {
-                Handle::Aes128(key) => Ok(key.as_slice().to_vec()),
+                Handle::Aes128(key) => Ok(AesExportedKey::Raw(key.as_slice().to_vec())),
-                Handle::Aes192(key) => Ok(key.as_slice().to_vec()),
+                Handle::Aes192(key) => Ok(AesExportedKey::Raw(key.as_slice().to_vec())),
-                Handle::Aes256(key) => Ok(key.as_slice().to_vec()),
+                Handle::Aes256(key) => Ok(AesExportedKey::Raw(key.as_slice().to_vec())),
             },
             KeyFormat::Jwk => {
-                // TODO: Support jwk
+                let (alg, k) = match key.handle() {
-                Err(Error::NotSupported)
+                    Handle::Aes128(key) => data_to_jwk_params("A128CBC", key.as_slice()),
+                    Handle::Aes192(key) => data_to_jwk_params("A192CBC", key.as_slice()),
+                    Handle::Aes256(key) => data_to_jwk_params("A256CBC", key.as_slice()),
+                };
+                let jwk = JsonWebKey {
+                    alg: Some(alg),
+                    crv: None,
+                    d: None,
+                    dp: None,
+                    dq: None,
+                    e: None,
+                    ext: Some(key.Extractable()),
+                    k: Some(k),
+                    key_ops: None,
+                    kty: Some(DOMString::from("oct")),
+                    n: None,
+                    oth: None,
+                    p: None,
+                    q: None,
+                    qi: None,
+                    use_: None,
+                    x: None,
+                    y: None,
+                };
+                Ok(AesExportedKey::Jwk(jwk))
             },
             _ => Err(Error::NotSupported),
         }
     }
 }
+
+pub enum AesExportedKey {
+    Raw(Vec<u8>),
+    Jwk(JsonWebKey),
+}
+
+fn data_to_jwk_params(alg: &str, key: &[u8]) -> (DOMString, DOMString) {
+    let mut data = BASE64_STANDARD.encode(key);
+    data.retain(|c| c != '=');
+    (DOMString::from(alg), DOMString::from(data))
+}

components/script/dom/webidls/SubtleCrypto.webidl

@@ -20,12 +20,12 @@ enum KeyFormat { "raw", "spki", "pkcs8", "jwk" };
 
 [SecureContext,Exposed=(Window,Worker),Pref="dom.crypto.subtle.enabled"]
 interface SubtleCrypto {
-  // Promise<any> encrypt(AlgorithmIdentifier algorithm,
+  Promise<any> encrypt(AlgorithmIdentifier algorithm,
-  //                      CryptoKey key,
+                       CryptoKey key,
-  //                      BufferSource data);
+                       BufferSource data);
-  // Promise<any> decrypt(AlgorithmIdentifier algorithm,
+  Promise<any> decrypt(AlgorithmIdentifier algorithm,
-  //                      CryptoKey key,
+                       CryptoKey key,
-  //                      BufferSource data);
+                       BufferSource data);
   // Promise<any> sign(AlgorithmIdentifier algorithm,
   //                   CryptoKey key,
   //                   BufferSource data);
@@ -48,11 +48,11 @@ interface SubtleCrypto {
   //                         CryptoKey baseKey,
   //                         optional unsigned long? length = null);
 
-  // Promise<CryptoKey> importKey(KeyFormat format,
+  Promise<CryptoKey> importKey(KeyFormat format,
-  //                        (BufferSource or JsonWebKey) keyData,
+                         (BufferSource or JsonWebKey) keyData,
-  //                        AlgorithmIdentifier algorithm,
+                         AlgorithmIdentifier algorithm,
-  //                        boolean extractable,
+                         boolean extractable,
-  //                        sequence<KeyUsage> keyUsages );
+                         sequence<KeyUsage> keyUsages );
   Promise<any> exportKey(KeyFormat format, CryptoKey key);
 
   // Promise<any> wrapKey(KeyFormat format,
@@ -85,3 +85,37 @@ dictionary AesDerivedKeyParams : Algorithm {
 dictionary AesCbcParams : Algorithm {
   required BufferSource iv;
 };
+
+// JWK
+dictionary RsaOtherPrimesInfo {
+  // The following fields are defined in Section 6.3.2.7 of JSON Web Algorithms
+  DOMString r;
+  DOMString d;
+  DOMString t;
+};
+
+dictionary JsonWebKey {
+  // The following fields are defined in Section 3.1 of JSON Web Key
+  DOMString kty;
+  DOMString use;
+  sequence<DOMString> key_ops;
+  DOMString alg;
+
+  // The following fields are defined in JSON Web Key Parameters Registration
+  boolean ext;
+
+  // The following fields are defined in Section 6 of JSON Web Algorithms
+  DOMString crv;
+  DOMString x;
+  DOMString y;
+  DOMString d;
+  DOMString n;
+  DOMString e;
+  DOMString p;
+  DOMString q;
+  DOMString dp;
+  DOMString dq;
+  DOMString qi;
+  sequence<RsaOtherPrimesInfo> oth;
+  DOMString k;
+};

tests/wpt/meta-legacy-layout/WebCryptoAPI/algorithm-discards-context.https.window.js.ini

@@ -1,8 +1,5 @@
 [algorithm-discards-context.https.window.html]
   expected: TIMEOUT
-  [Context is discarded in importKey]
-    expected: TIMEOUT
-
   [Context is discarded in encrypt]
     expected: TIMEOUT
 

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve25519.https.any.js.ini

@@ -1,7 +1,4 @@
 [cfrg_curves_bits_curve25519.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X25519 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -20,11 +17,45 @@
   [X25519 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
 
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 short result]
+    expected: FAIL
+
+  [X25519 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
+  [X25519 asking for too many bits]
+    expected: FAIL
+
 
 [cfrg_curves_bits_curve25519.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X25519 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -42,3 +73,39 @@
 
   [X25519 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
+
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 short result]
+    expected: FAIL
+
+  [X25519 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
+  [X25519 asking for too many bits]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js.ini

@@ -1,7 +1,5 @@
 [cfrg_curves_bits_curve448.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X448 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -17,11 +15,44 @@
   [X448 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
 
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 short result]
+    expected: FAIL
+
+  [X448 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
+  [X448 asking for too many bits]
+    expected: FAIL
+
 
 [cfrg_curves_bits_curve448.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X448 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -36,3 +67,39 @@
 
   [X448 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
+
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 short result]
+    expected: FAIL
+
+  [X448 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
+  [X448 asking for too many bits]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve25519.https.any.js.ini

@@ -1,7 +1,4 @@
 [cfrg_curves_keys_curve25519.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X25519 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -23,11 +20,36 @@
   [Key derivation using a X25519 generated keys.]
     expected: FAIL
 
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
 
 [cfrg_curves_keys_curve25519.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X25519 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -48,3 +70,30 @@
 
   [Key derivation using a X25519 generated keys.]
     expected: FAIL
+
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js.ini

@@ -1,7 +1,5 @@
 [cfrg_curves_keys_curve448.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X448 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -20,11 +18,35 @@
   [Key derivation using a X448 generated keys.]
     expected: FAIL
 
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
 
 [cfrg_curves_keys_curve448.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X448 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -42,3 +64,30 @@
 
   [Key derivation using a X448 generated keys.]
     expected: FAIL
+
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/ecdh_bits.https.any.js.ini

@@ -2,7 +2,121 @@
   [WebCryptoAPI: deriveBits() Using ECDH]
     expected: FAIL
 
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 short result]
+    expected: FAIL
+
+  [P-521 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-521 asking for too many bits]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 short result]
+    expected: FAIL
+
+  [P-256 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 asking for too many bits]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 short result]
+    expected: FAIL
+
+  [P-384 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 asking for too many bits]
     expected: FAIL
 
 
@@ -10,6 +124,119 @@
   [WebCryptoAPI: deriveBits() Using ECDH]
     expected: FAIL
 
-  [setup - define tests]
+  [P-521 good parameters]
     expected: FAIL
 
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 short result]
+    expected: FAIL
+
+  [P-521 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-521 asking for too many bits]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 short result]
+    expected: FAIL
+
+  [P-256 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 asking for too many bits]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 short result]
+    expected: FAIL
+
+  [P-384 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 asking for too many bits]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/derive_bits_keys/ecdh_keys.https.any.js.ini

@@ -2,7 +2,94 @@
   [WebCryptoAPI: deriveKey() Using ECDH]
     expected: FAIL
 
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
     expected: FAIL
 
 
@@ -10,6 +97,92 @@
   [WebCryptoAPI: deriveKey() Using ECDH]
     expected: FAIL
 
-  [setup - define tests]
+  [P-521 good parameters]
     expected: FAIL
 
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/encrypt_decrypt/aes_cbc.https.any.js.ini

@@ -1,5 +1,20 @@
 [aes_cbc.https.any.html]
-  expected: ERROR
+  [AES-CBC 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
 
 [aes_cbc.https.any.worker.html]
-  expected: ERROR
+  [AES-CBC 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 256-bit key with mismatched key and algorithm]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/encrypt_decrypt/aes_ctr.https.any.js.ini

@@ -1,5 +1,200 @@
 [aes_ctr.https.any.worker.html]
-  expected: ERROR
+  [importKey step: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
 
 [aes_ctr.https.any.html]
-  expected: ERROR
+  [importKey step: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/encrypt_decrypt/rsa_oaep.https.any.js.ini

@@ -1,5 +1,650 @@
 [rsa_oaep.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no encrypt usage]
+    expected: FAIL
+
 
 [rsa_oaep.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no encrypt usage]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js.ini

@@ -1,878 +0,0 @@
-[successes_AES-CBC.https.any.html]
-  [Untitled]
-    expected: FAIL
-
-  [WebCryptoAPI: generateKey() Successful Calls]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-
-[successes_AES-CBC.https.any.worker.html]
-  [Untitled]
-    expected: FAIL
-
-  [WebCryptoAPI: generateKey() Successful Calls]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/idlharness.https.any.js.ini

@@ -2,12 +2,6 @@
   [idlharness]
     expected: FAIL
 
-  [SubtleCrypto interface: operation encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
-  [SubtleCrypto interface: operation decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation sign(AlgorithmIdentifier, CryptoKey, BufferSource)]
     expected: FAIL
 
@@ -35,18 +29,6 @@
   [SubtleCrypto interface: operation unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, [object Object\])]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling encrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
-  [SubtleCrypto interface: crypto.subtle must inherit property "decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling decrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "sign(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
     expected: FAIL
 
@@ -107,12 +89,6 @@
   [SubtleCrypto interface: crypto.subtle must inherit property "unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: operation deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
     expected: FAIL
 
@@ -122,9 +98,6 @@
   [SubtleCrypto interface: crypto.subtle must inherit property "deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
     expected: FAIL
 
-  [SubtleCrypto interface: operation importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
-    expected: FAIL
-
   [SubtleCrypto interface: calling deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
     expected: FAIL
 
@@ -142,12 +115,6 @@
   [idlharness]
     expected: FAIL
 
-  [SubtleCrypto interface: operation encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
-  [SubtleCrypto interface: operation decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation sign(AlgorithmIdentifier, CryptoKey, BufferSource)]
     expected: FAIL
 
@@ -175,18 +142,6 @@
   [SubtleCrypto interface: operation unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, [object Object\])]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling encrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
-  [SubtleCrypto interface: crypto.subtle must inherit property "decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling decrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "sign(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
     expected: FAIL
 
@@ -247,12 +202,6 @@
   [SubtleCrypto interface: crypto.subtle must inherit property "unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: operation deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
     expected: FAIL
 
@@ -262,9 +211,6 @@
   [SubtleCrypto interface: crypto.subtle must inherit property "deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
     expected: FAIL
 
-  [SubtleCrypto interface: operation importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
-    expected: FAIL
-
   [SubtleCrypto interface: calling deriveKey(AlgorithmIdentifier, CryptoKey, AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
     expected: FAIL
 

tests/wpt/meta-legacy-layout/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js.ini

@@ -1,8 +0,0 @@
-[importKey-unsettled-promise.https.any.worker.html]
-  [WebCryptoAPI: Assure promise returned by importKey is settled.]
-    expected: FAIL
-
-
-[importKey-unsettled-promise.https.any.html]
-  [WebCryptoAPI: Assure promise returned by importKey is settled.]
-    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/import_export/symmetric_importKey.https.any.js.ini

@@ -107,114 +107,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
     expected: FAIL
 
@@ -737,42 +629,6 @@
   [Empty Usages: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [\])]
     expected: FAIL
 
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
   [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [\])]
     expected: FAIL
 
@@ -971,42 +827,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
@@ -1279,114 +1099,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
     expected: FAIL
 
@@ -1909,42 +1621,6 @@
   [Empty Usages: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [\])]
     expected: FAIL
 
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
   [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [\])]
     expected: FAIL
 
@@ -2143,42 +1819,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 

tests/wpt/meta-legacy-layout/WebCryptoAPI/sign_verify/hmac.https.any.js.ini

@@ -1,5 +1,242 @@
 [hmac.https.any.html]
-  expected: ERROR
+  [generate wrong key step: HMAC with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-1 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to short signature]
+    expected: FAIL
+
 
 [hmac.https.any.worker.html]
-  expected: ERROR
+  [generate wrong key step: HMAC with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-1 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to short signature]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/sign_verify/rsa_pkcs.https.any.js.ini

@@ -1,5 +1,266 @@
 [rsa_pkcs.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered plaintext]
+    expected: FAIL
+
 
 [rsa_pkcs.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered plaintext]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/sign_verify/rsa_pss.https.any.js.ini

@@ -1,5 +1,578 @@
 [rsa_pss.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered plaintext]
+    expected: FAIL
+
 
 [rsa_pss.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered plaintext]
+    expected: FAIL

tests/wpt/meta-legacy-layout/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.any.js.ini

@@ -5,6 +5,15 @@
   [Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CBC]
     expected: FAIL
 
+  [Can wrap and unwrap AES-CBC keys using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can unwrap AES-CBC non-extractable keys using jwk and AES-CBC]
+    expected: FAIL
+
 
 [wrapKey_unwrapKey.https.any.worker.html]
   [Can wrap and unwrap AES-CBC keys using raw and AES-CBC]
@@ -12,3 +21,12 @@
 
   [Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CBC]
     expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can unwrap AES-CBC non-extractable keys using jwk and AES-CBC]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/algorithm-discards-context.https.window.js.ini

@@ -1,8 +1,5 @@
 [algorithm-discards-context.https.window.html]
   expected: TIMEOUT
-  [Context is discarded in importKey]
-    expected: TIMEOUT
-
   [Context is discarded in encrypt]
     expected: TIMEOUT
 

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve25519.https.any.js.ini

@@ -1,7 +1,5 @@
 [cfrg_curves_bits_curve25519.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X25519 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -20,11 +18,44 @@
   [X25519 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
 
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 short result]
+    expected: FAIL
+
+  [X25519 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
+  [X25519 asking for too many bits]
+    expected: FAIL
+
 
 [cfrg_curves_bits_curve25519.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X25519 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -42,3 +73,39 @@
 
   [X25519 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
+
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 short result]
+    expected: FAIL
+
+  [X25519 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
+  [X25519 asking for too many bits]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits_curve448.https.any.js.ini

@@ -1,7 +1,4 @@
 [cfrg_curves_bits_curve448.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X448 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -17,11 +14,45 @@
   [X448 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
 
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 short result]
+    expected: FAIL
+
+  [X448 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
+  [X448 asking for too many bits]
+    expected: FAIL
+
 
 [cfrg_curves_bits_curve448.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X448 key derivation checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -36,3 +67,39 @@
 
   [X448 key derivation checks for all-zero value result with a key of order p+1 (=1, order 1)]
     expected: FAIL
+
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 short result]
+    expected: FAIL
+
+  [X448 non-multiple of 8 bits]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveBits usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
+  [X448 asking for too many bits]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve25519.https.any.js.ini

@@ -1,7 +1,4 @@
 [cfrg_curves_keys_curve25519.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X25519 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -23,11 +20,36 @@
   [Key derivation using a X25519 generated keys.]
     expected: FAIL
 
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL
+
 
 [cfrg_curves_keys_curve25519.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X25519 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -48,3 +70,30 @@
 
   [Key derivation using a X25519 generated keys.]
     expected: FAIL
+
+  [X25519 good parameters]
+    expected: FAIL
+
+  [X25519 mixed case parameters]
+    expected: FAIL
+
+  [X25519 missing public property]
+    expected: FAIL
+
+  [X25519 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X25519 mismatched algorithms]
+    expected: FAIL
+
+  [X25519 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X25519 base key is not a private key]
+    expected: FAIL
+
+  [X25519 public property value is a private key]
+    expected: FAIL
+
+  [X25519 public property value is a secret key]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/cfrg_curves_keys_curve448.https.any.js.ini

@@ -1,7 +1,4 @@
 [cfrg_curves_keys_curve448.https.any.worker.html]
-  [setup - define tests]
-    expected: FAIL
-
   [X448 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -20,11 +17,36 @@
   [Key derivation using a X448 generated keys.]
     expected: FAIL
 
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL
+
 
 [cfrg_curves_keys_curve448.https.any.html]
-  [setup - define tests]
+  expected: ERROR
-    expected: FAIL
-
   [X448 deriveBits checks for all-zero value result with a key of order 0]
     expected: FAIL
 
@@ -42,3 +64,30 @@
 
   [Key derivation using a X448 generated keys.]
     expected: FAIL
+
+  [X448 good parameters]
+    expected: FAIL
+
+  [X448 mixed case parameters]
+    expected: FAIL
+
+  [X448 missing public property]
+    expected: FAIL
+
+  [X448 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [X448 mismatched algorithms]
+    expected: FAIL
+
+  [X448 no deriveKey usage for base key]
+    expected: FAIL
+
+  [X448 base key is not a private key]
+    expected: FAIL
+
+  [X448 public property value is a private key]
+    expected: FAIL
+
+  [X448 public property value is a secret key]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/ecdh_bits.https.any.js.ini

@@ -1,8 +1,236 @@
 [ecdh_bits.https.any.html]
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 short result]
+    expected: FAIL
+
+  [P-521 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-521 asking for too many bits]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 short result]
+    expected: FAIL
+
+  [P-256 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 asking for too many bits]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 short result]
+    expected: FAIL
+
+  [P-384 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 asking for too many bits]
     expected: FAIL
 
 
 [ecdh_bits.https.any.worker.html]
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 short result]
+    expected: FAIL
+
+  [P-521 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-521 asking for too many bits]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 short result]
+    expected: FAIL
+
+  [P-256 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 asking for too many bits]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 short result]
+    expected: FAIL
+
+  [P-384 non-multiple of 8 bits]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveBits usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 asking for too many bits]
     expected: FAIL

tests/wpt/meta/WebCryptoAPI/derive_bits_keys/ecdh_keys.https.any.js.ini

@@ -1,8 +1,182 @@
 [ecdh_keys.https.any.html]
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
     expected: FAIL
 
 
 [ecdh_keys.https.any.worker.html]
-  [setup - define tests]
+  [P-521 good parameters]
+    expected: FAIL
+
+  [P-521 mixed case parameters]
+    expected: FAIL
+
+  [P-521 missing public curve]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-521 mismatched curves]
+    expected: FAIL
+
+  [P-521 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-521 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-521 base key is not a private key]
+    expected: FAIL
+
+  [P-521 public property value is a private key]
+    expected: FAIL
+
+  [P-521 public property value is a secret key]
+    expected: FAIL
+
+  [P-256 good parameters]
+    expected: FAIL
+
+  [P-256 mixed case parameters]
+    expected: FAIL
+
+  [P-256 missing public curve]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-256 mismatched curves]
+    expected: FAIL
+
+  [P-256 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-256 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-256 base key is not a private key]
+    expected: FAIL
+
+  [P-256 public property value is a private key]
+    expected: FAIL
+
+  [P-256 public property value is a secret key]
+    expected: FAIL
+
+  [P-384 good parameters]
+    expected: FAIL
+
+  [P-384 mixed case parameters]
+    expected: FAIL
+
+  [P-384 missing public curve]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not a CryptoKey]
+    expected: FAIL
+
+  [P-384 mismatched curves]
+    expected: FAIL
+
+  [P-384 public property of algorithm is not an ECDSA public key]
+    expected: FAIL
+
+  [P-384 no deriveKey usage for base key]
+    expected: FAIL
+
+  [P-384 base key is not a private key]
+    expected: FAIL
+
+  [P-384 public property value is a private key]
+    expected: FAIL
+
+  [P-384 public property value is a secret key]
     expected: FAIL

tests/wpt/meta/WebCryptoAPI/encrypt_decrypt/aes_cbc.https.any.js.ini

@@ -1,5 +1,20 @@
 [aes_cbc.https.any.worker.html]
-  expected: ERROR
+  [AES-CBC 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
 
 [aes_cbc.https.any.html]
-  expected: ERROR
+  [AES-CBC 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [AES-CBC 256-bit key with mismatched key and algorithm]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/encrypt_decrypt/aes_ctr.https.any.js.ini

@@ -1,5 +1,200 @@
 [aes_ctr.https.any.html]
-  expected: ERROR
+  [importKey step: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
 
 [aes_ctr.https.any.worker.html]
-  expected: ERROR
+  [importKey step: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with altered plaintext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 128-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 192-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step for decryption: AES-CTR 256-bit key with altered ciphertext]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without encrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key with mismatched key and algorithm]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key without decrypt usage]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 128-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 192-bit key, 129-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 0-bit counter]
+    expected: FAIL
+
+  [importKey step: decryption AES-CTR 256-bit key, 129-bit counter]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/encrypt_decrypt/rsa_oaep.https.any.js.ini

@@ -1,5 +1,650 @@
 [rsa_oaep.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no encrypt usage]
+    expected: FAIL
+
 
 [rsa_oaep.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label decryption with altered ciphertext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using publicKey to decrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no decrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label too long plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label using privateKey to encrypt]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and no label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and empty label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-1 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-256 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-384 and a label no encrypt usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-OAEP with SHA-512 and a label no encrypt usage]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js.ini

@@ -1,866 +0,0 @@
-[successes_AES-CBC.https.any.html]
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-
-[successes_AES-CBC.https.any.worker.html]
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey\])]
-    expected: FAIL
-
-  [Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey\])]
-    expected: FAIL

tests/wpt/meta/WebCryptoAPI/idlharness.https.any.js.ini

@@ -1,10 +1,4 @@
 [idlharness.https.any.worker.html]
-  [SubtleCrypto interface: operation encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
-  [SubtleCrypto interface: operation decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation sign(AlgorithmIdentifier, CryptoKey, BufferSource)]
     expected: FAIL
 
@@ -20,27 +14,12 @@
   [SubtleCrypto interface: operation deriveBits(AlgorithmIdentifier, CryptoKey, unsigned long)]
     expected: FAIL
 
-  [SubtleCrypto interface: operation importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation wrapKey(KeyFormat, CryptoKey, CryptoKey, AlgorithmIdentifier)]
     expected: FAIL
 
   [SubtleCrypto interface: operation unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling encrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
-  [SubtleCrypto interface: crypto.subtle must inherit property "decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling decrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "sign(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
     expected: FAIL
 
@@ -71,12 +50,6 @@
   [SubtleCrypto interface: calling deriveBits(AlgorithmIdentifier, CryptoKey, unsigned long) on crypto.subtle with too few arguments must throw TypeError]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "wrapKey(KeyFormat, CryptoKey, CryptoKey, AlgorithmIdentifier)" with the proper type]
     expected: FAIL
 
@@ -100,12 +73,6 @@
 
 
 [idlharness.https.any.html]
-  [SubtleCrypto interface: operation encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
-  [SubtleCrypto interface: operation decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation sign(AlgorithmIdentifier, CryptoKey, BufferSource)]
     expected: FAIL
 
@@ -121,27 +88,12 @@
   [SubtleCrypto interface: operation deriveBits(AlgorithmIdentifier, CryptoKey, unsigned long)]
     expected: FAIL
 
-  [SubtleCrypto interface: operation importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
-    expected: FAIL
-
   [SubtleCrypto interface: operation wrapKey(KeyFormat, CryptoKey, CryptoKey, AlgorithmIdentifier)]
     expected: FAIL
 
   [SubtleCrypto interface: operation unwrapKey(KeyFormat, BufferSource, CryptoKey, AlgorithmIdentifier, AlgorithmIdentifier, boolean, sequence<KeyUsage>)]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "encrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling encrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
-  [SubtleCrypto interface: crypto.subtle must inherit property "decrypt(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling decrypt(AlgorithmIdentifier, CryptoKey, BufferSource) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "sign(AlgorithmIdentifier, CryptoKey, BufferSource)" with the proper type]
     expected: FAIL
 
@@ -172,12 +124,6 @@
   [SubtleCrypto interface: calling deriveBits(AlgorithmIdentifier, CryptoKey, unsigned long) on crypto.subtle with too few arguments must throw TypeError]
     expected: FAIL
 
-  [SubtleCrypto interface: crypto.subtle must inherit property "importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>)" with the proper type]
-    expected: FAIL
-
-  [SubtleCrypto interface: calling importKey(KeyFormat, (BufferSource or JsonWebKey), AlgorithmIdentifier, boolean, sequence<KeyUsage>) on crypto.subtle with too few arguments must throw TypeError]
-    expected: FAIL
-
   [SubtleCrypto interface: crypto.subtle must inherit property "wrapKey(KeyFormat, CryptoKey, CryptoKey, AlgorithmIdentifier)" with the proper type]
     expected: FAIL
 

tests/wpt/meta/WebCryptoAPI/import_export/crashtests/importKey-unsettled-promise.https.any.js.ini

@@ -1,8 +0,0 @@
-[importKey-unsettled-promise.https.any.html]
-  [WebCryptoAPI: Assure promise returned by importKey is settled.]
-    expected: FAIL
-
-
-[importKey-unsettled-promise.https.any.worker.html]
-  [WebCryptoAPI: Assure promise returned by importKey is settled.]
-    expected: FAIL

tests/wpt/meta/WebCryptoAPI/import_export/symmetric_importKey.https.any.js.ini

@@ -107,114 +107,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
     expected: FAIL
 
@@ -737,42 +629,6 @@
   [Empty Usages: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [\])]
     expected: FAIL
 
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
   [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [\])]
     expected: FAIL
 
@@ -971,42 +827,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
@@ -1279,114 +1099,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
     expected: FAIL
 
@@ -1909,42 +1621,6 @@
   [Empty Usages: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [\])]
     expected: FAIL
 
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
-  [Empty Usages: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [\])]
-    expected: FAIL
-
   [Empty Usages: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [\])]
     expected: FAIL
 
@@ -2143,42 +1819,6 @@
   [Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
-  [Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt, decrypt, encrypt, decrypt\])]
-    expected: FAIL
-
   [Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt, decrypt, encrypt, decrypt\])]
     expected: FAIL
 

tests/wpt/meta/WebCryptoAPI/sign_verify/hmac.https.any.js.ini

@@ -1,5 +1,242 @@
 [hmac.https.any.html]
-  expected: ERROR
+  [generate wrong key step: HMAC with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-1 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to short signature]
+    expected: FAIL
+
 
 [hmac.https.any.worker.html]
-  expected: ERROR
+  [generate wrong key step: HMAC with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-1 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-256 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-384 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [generate wrong key step: HMAC with SHA-512 verifying with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to wrong signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-1 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-256 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-384 verification failure due to short signature]
+    expected: FAIL
+
+  [importVectorKeys step: HMAC with SHA-512 verification failure due to short signature]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/sign_verify/rsa_pkcs.https.any.js.ini

@@ -1,5 +1,266 @@
 [rsa_pkcs.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered plaintext]
+    expected: FAIL
+
 
 [rsa_pkcs.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-1 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-256 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-384 verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSASSA-PKCS1-v1_5 with SHA-512 verification failure with altered plaintext]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/sign_verify/rsa_pss.https.any.js.ini

@@ -1,5 +1,578 @@
 [rsa_pss.https.any.worker.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered plaintext]
+    expected: FAIL
+
 
 [rsa_pss.https.any.html]
-  expected: ERROR
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with altered signature after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted with altered plaintext after call]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using privateKey to verify]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted using publicKey to sign]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted no verify usage]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted round trip]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted signing with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification with wrong algorithm name]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered signature]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with wrong saltLength]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512 and no salt verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-1, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-256, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-384, salted verification failure with altered plaintext]
+    expected: FAIL
+
+  [importVectorKeys step: RSA-PSS with SHA-512, salted verification failure with altered plaintext]
+    expected: FAIL

tests/wpt/meta/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.any.js.ini

@@ -5,6 +5,15 @@
   [Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CBC]
     expected: FAIL
 
+  [Can wrap and unwrap AES-CBC keys using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can unwrap AES-CBC non-extractable keys using jwk and AES-CBC]
+    expected: FAIL
+
 
 [wrapKey_unwrapKey.https.any.worker.html]
   [Can wrap and unwrap AES-CBC keys using raw and AES-CBC]
@@ -12,3 +21,12 @@
 
   [Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CBC]
     expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CBC]
+    expected: FAIL
+
+  [Can unwrap AES-CBC non-extractable keys using jwk and AES-CBC]
+    expected: FAIL