Attachment 342589 Details for Bug 186565 – Patch

[patch] Patch

bug-186565-20180612132200.patch (text/plain), 176.21 KB, created by Dawei Fenton (:realdawei) on 2018-06-12 13:22:14 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Dawei Fenton (:realdawei)

Created: 2018-06-12 13:22:14 PDT

Size: 176.21 KB

patch

obsolete

>Subversion Revision: 232754
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 8b9d38165d4800f1a7bb9d5234c900e34b178a5e..8d1d1a7aa6321c1381464cc608f358cee6b6563b 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,15 @@
>+2018-06-12  David Fenton  <david_fenton@apple.com>
>+
>+        Rebaseline WebCrypto API tests for High Sierra after r232641.
>+        https://bugs.webkit.org/show_bug.cgi?id=186565
>+
>+        Unreviewed test gardening.
>+
>+        * platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt: Added.
>+        * platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt: Added.
>+        * platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt: Added.
>+        * platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt: Added.
>+
> 2018-06-12  Jianjun Zhu  <jianjun.zhu@intel.com>
> 
>         Hash deviceId and groupId of MediaTrackCapabilities.
>diff --git a/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt b/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..96c93d4466644c64a4a9c572f28ae98b10d4b19d
>--- /dev/null
>+++ b/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt
>@@ -0,0 +1,394 @@
>+
>+PASS Bad algorithm: generateKey(AES, false, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [sign]) 
>+PASS Bad algorithm: generateKey(AES, true, [sign]) 
>+PASS Bad algorithm: generateKey(AES, RED, [sign]) 
>+PASS Bad algorithm: generateKey(AES, 7, [sign]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, false, []) 
>+PASS Bad algorithm: generateKey(AES, true, []) 
>+PASS Bad algorithm: generateKey(AES, RED, []) 
>+PASS Bad algorithm: generateKey(AES, 7, []) 
>+PASS Bad algorithm: generateKey(AES, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, []) 
>+PASS Bad algorithm: generateKey({name: AES}, true, []) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, []) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, []) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt b/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..96c93d4466644c64a4a9c572f28ae98b10d4b19d
>--- /dev/null
>+++ b/LayoutTests/platform/mac-sierra/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt
>@@ -0,0 +1,394 @@
>+
>+PASS Bad algorithm: generateKey(AES, false, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey(AES, false, [sign]) 
>+PASS Bad algorithm: generateKey(AES, true, [sign]) 
>+PASS Bad algorithm: generateKey(AES, RED, [sign]) 
>+PASS Bad algorithm: generateKey(AES, 7, [sign]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, false, []) 
>+PASS Bad algorithm: generateKey(AES, true, []) 
>+PASS Bad algorithm: generateKey(AES, RED, []) 
>+PASS Bad algorithm: generateKey(AES, 7, []) 
>+PASS Bad algorithm: generateKey(AES, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, false, []) 
>+PASS Bad algorithm: generateKey({name: AES}, true, []) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, []) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, []) 
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, []) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, []) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, decrypt]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, []) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits]) 
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) assert_equals: Bad usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) assert_equals: Bad algorithm property not supported expected "OperationError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b95f2d06e0766346339de198c24eb4454eba8762
>--- /dev/null
>+++ b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt
>@@ -0,0 +1,394 @@
>+
>+PASS Bad algorithm: generateKey(AES, false, [decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [sign])
>+PASS Bad algorithm: generateKey(AES, true, [sign])
>+PASS Bad algorithm: generateKey(AES, RED, [sign])
>+PASS Bad algorithm: generateKey(AES, 7, [sign])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, false, [])
>+PASS Bad algorithm: generateKey(AES, true, [])
>+PASS Bad algorithm: generateKey(AES, RED, [])
>+PASS Bad algorithm: generateKey(AES, 7, [])
>+PASS Bad algorithm: generateKey(AES, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, false, [])
>+PASS Bad algorithm: generateKey({name: AES}, true, [])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [])
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify])
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b95f2d06e0766346339de198c24eb4454eba8762
>--- /dev/null
>+++ b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt
>@@ -0,0 +1,394 @@
>+
>+PASS Bad algorithm: generateKey(AES, false, [decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey(AES, false, [sign])
>+PASS Bad algorithm: generateKey(AES, true, [sign])
>+PASS Bad algorithm: generateKey(AES, RED, [sign])
>+PASS Bad algorithm: generateKey(AES, 7, [sign])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey(AES, false, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, true, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, RED, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, 7, [deriveBits])
>+PASS Bad algorithm: generateKey(AES, false, [])
>+PASS Bad algorithm: generateKey(AES, true, [])
>+PASS Bad algorithm: generateKey(AES, RED, [])
>+PASS Bad algorithm: generateKey(AES, 7, [])
>+PASS Bad algorithm: generateKey(AES, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey(AES, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: AES}, false, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, true, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [sign])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: AES}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, false, [])
>+PASS Bad algorithm: generateKey({name: AES}, true, [])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [])
>+PASS Bad algorithm: generateKey({name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({length: 128, name: AES-CFB}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: MD5, name: HMAC}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({hash: SHA, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, decrypt])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits, sign])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, false, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, true, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, RED, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad algorithm: generateKey({name: EC, namedCurve: P521}, 7, [decrypt, sign, deriveBits, decrypt, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits])
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify])
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify])
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [])
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [])
>+

Actions: View | Formatted Diff | Diff

Attachments on bug 186565: 342551 | 342556 | 342571 | 342574 | 342587 | 342589