Attachment 342251 Details for Bug 186267 – Patch

[patch] Patch

bug-186267-20180608090108.patch (text/plain), 3.22 MB, created by Brendan McLoughlin on 2018-06-08 06:01:10 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Brendan McLoughlin

Created: 2018-06-08 06:01:10 PDT

Size: 3.22 MB

patch

obsolete

>Subversion Revision: 232538
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 6a2fd1f186149be1e499b87755fdca50b644a9f1..f0bcf541cc059e146decce8ce183fc2f68887808 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,18 @@
>+2018-06-08  Brendan McLoughlin  <brendan@bocoup.com>
>+
>+        Sync web-platform-tests repo to 197cdad
>+        https://bugs.webkit.org/show_bug.cgi?id=186267
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestExpectations:
>+        * platform/ios/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt:
>+        * platform/mac-wk2/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt: Added.
>+        * platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt: Added.
>+        * platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt: Added.
>+        * platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt: Removed.
>+        * platform/mac/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt:
>+
> 2018-06-06  Alicia Boya GarcÃa  <aboya@igalia.com>
> 
>         [GTK] Unreviewed test gardening
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index 5be1710baf367d82bef81ba714574a272e49fbbc..8fffc12047c3e99043a8f6e4cf66dc3773dc0321 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,309 @@
>+2018-06-08  Brendan McLoughlin  <brendan@bocoup.com>
>+
>+        Sync web-platform-tests repo to 197cdad
>+        https://bugs.webkit.org/show_bug.cgi?id=186267
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * resources/resource-files.json:
>+        * web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html:
>+        * web-platform-tests/2dcontext/imagebitmap/w3c-import.log:
>+        * web-platform-tests/FileAPI/BlobURL/support/file_test2.txt: Added.
>+        * web-platform-tests/FileAPI/BlobURL/support/w3c-import.log:
>+        * web-platform-tests/FileAPI/FileReader/support/file_test1.txt: Added.
>+        * web-platform-tests/FileAPI/FileReader/workers-expected.txt: Added.
>+        * web-platform-tests/FileAPI/FileReader/workers.html: Added.
>+        * web-platform-tests/FileAPI/blob/Blob-constructor-endings-expected.txt: Added.
>+        * web-platform-tests/FileAPI/blob/Blob-constructor-endings.html: Added.
>+        * web-platform-tests/FileAPI/blob/w3c-import.log:
>+        * web-platform-tests/FileAPI/file/File-constructor-endings-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/File-constructor-endings.html: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative.html: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-utf-8-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-utf-8.html: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative.html: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative-expected.txt: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative.html: Added.
>+        * web-platform-tests/FileAPI/file/send-file-form.html: Added.
>+        * web-platform-tests/FileAPI/historical.https-expected.txt:
>+        * web-platform-tests/FileAPI/historical.https.html:
>+        * web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads-expected.txt:
>+        * web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads.html:
>+        * web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString-expected.txt: Added.
>+        * web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString.html: Added.
>+        * web-platform-tests/FileAPI/reading-data-section/w3c-import.log:
>+        * web-platform-tests/FileAPI/support/send-file-form-helper.js: Added.
>+        (const.formPostFileUploadTest):
>+        * web-platform-tests/FileAPI/support/w3c-import.log:
>+        * web-platform-tests/FileAPI/unicode-expected.txt: Added.
>+        * web-platform-tests/FileAPI/unicode.html: Added.
>+        * web-platform-tests/FileAPI/url/resources/w3c-import.log: Copied from LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/w3c-import.log.
>+        * web-platform-tests/FileAPI/url/url-in-tags-revoke.window.js: Added.
>+        (async_test.t.frame.onload.t.step_func_done):
>+        (async_test.t.frame.onload.t.step_func):
>+        (async_test.t.add_completion_callback):
>+        (async_test.t.win.onload.t.step_func_done):
>+        (receive_message_on_channel):
>+        (async_test.t.const.blob.new.Blob.window_contents_for_channel):
>+        (async_test.t.e.onload.t.step_func_done):
>+        * web-platform-tests/FileAPI/url/url-in-tags.window.js:
>+        (async_test.t.frame.contentWindow.onscroll.t.step_func_done):
>+        * web-platform-tests/FileAPI/url/url-reload.window.js: Added.
>+        (blob_url_reload_test):
>+        * web-platform-tests/FileAPI/url/w3c-import.log:
>+        * web-platform-tests/FileAPI/w3c-import.log:
>+        * web-platform-tests/IndexedDB/bigint_value-expected.txt: Added.
>+        * web-platform-tests/IndexedDB/bigint_value.htm: Added.
>+        * web-platform-tests/IndexedDB/historical-expected.txt:
>+        * web-platform-tests/IndexedDB/historical.html:
>+        * web-platform-tests/IndexedDB/idbcursor-iterating-update-expected.txt: Added.
>+        * web-platform-tests/IndexedDB/idbcursor-iterating-update.htm: Added.
>+        * web-platform-tests/IndexedDB/interleaved-cursors-common.js: Added.
>+        (objectKey):
>+        (objectValue):
>+        (writeCursorObjects):
>+        (interleaveCursors):
>+        * web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt: Added.
>+        * web-platform-tests/IndexedDB/interleaved-cursors-large.html: Added.
>+        * web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt: Added.
>+        * web-platform-tests/IndexedDB/interleaved-cursors-small.html: Added.
>+        * web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt:
>+        * web-platform-tests/IndexedDB/keypath-special-identifiers.htm:
>+        * web-platform-tests/IndexedDB/keypath.htm:
>+        * web-platform-tests/IndexedDB/support.js:
>+        (add_completion_callback):
>+        (indexeddb_test):
>+        * web-platform-tests/IndexedDB/w3c-import.log:
>+        * web-platform-tests/IndexedDB/wasm-module-value-expected.txt: Added.
>+        * web-platform-tests/IndexedDB/wasm-module-value.html: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt:
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt:
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt:
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt:
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker-expected.txt: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker-expected.txt: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker-expected.txt: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker-expected.txt: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt: Copied from LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt: Renamed from LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker-expected.txt.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes.js:
>+        (run_test):
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.js: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.js: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https-expected.txt: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https.html: Removed.
>+        * web-platform-tests/WebCryptoAPI/generateKey/w3c-import.log:
>+        * web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object-expected.txt: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object.html: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object-expected.txt: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object.html: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any-expected.txt: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.html: Copied from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.js: Added.
>+        (test):
>+        (test.regExp.Symbol.iterator):
>+        (promise_test.async):
>+        * web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker-expected.txt: Added.
>+        * web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker.html: Renamed from LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html.
>+        * web-platform-tests/WebIDL/ecmascript-binding/w3c-import.log:
>+        * web-platform-tests/background-fetch/interfaces.html:
>+        * web-platform-tests/background-fetch/interfaces.worker.js:
>+        (promise_test.async):
>+        (promise_test): Deleted.
>+        * web-platform-tests/beacon/OWNERS: Added.
>+        * web-platform-tests/beacon/beacon-common.sub.js:
>+        * web-platform-tests/beacon/beacon-cors.sub.window.js:
>+        (runTests.self.buildId):
>+        (runTests.self.buildBaseUrl):
>+        (runTests.self.buildTargetUrl):
>+        (runTests):
>+        * web-platform-tests/beacon/beacon-error.window.js:
>+        (promise_test.async):
>+        * web-platform-tests/beacon/beacon-navigate-expected.txt:
>+        * web-platform-tests/beacon/headers/header-content-type.html:
>+        * web-platform-tests/beacon/resources/beacon.py:
>+        (main):
>+        * web-platform-tests/beacon/w3c-import.log:
>+
> 2018-06-05  Youenn Fablet  <youenn@apple.com>
> 
>         ServiceWorker registration should store any script fetched through importScripts
>diff --git a/LayoutTests/TestExpectations b/LayoutTests/TestExpectations
>index 49d2ae1b4c9eb8bf1c2686c751270600ffc33a90..5b35b65a9941f2b1ed33f818608d3ab57b3fe968 100644
>--- a/LayoutTests/TestExpectations
>+++ b/LayoutTests/TestExpectations
>@@ -1423,14 +1423,10 @@ workers/wasm-long-compile.html [ Slow ]
> # Flaky WebCrypto API tests
> imported/w3c/web-platform-tests/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html [ Pass Failure ]
> imported/w3c/web-platform-tests/WebCryptoAPI/derive_bits_keys/pbkdf2.https.worker.html [ Pass Failure Slow ]
>-imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html [ Pass Failure ]
> 
> # WebCryptoAPI tests that take too long to complete
>-imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.html [ Skip ]
>-imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.html [ Slow ]
> imported/w3c/web-platform-tests/WebCryptoAPI/import_export/rsa_importKey.https.worker.html [ Slow ]
> imported/w3c/web-platform-tests/WebCryptoAPI/import_export/test_rsa_importKey.https.html [ Slow ]
>-imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.html [ Slow ]
> 
> # Imported Beacon test that is flaky because its last check is very slow.
> webkit.org/b/175202 imported/w3c/web-platform-tests/beacon/beacon-basic-string.html [ Pass Failure ]
>@@ -2012,3 +2008,4 @@ webkit.org/b/184800 http/tests/workers/worker-importScripts-banned-mimetype.html
> webkit.org/b/184802 http/tests/security/contentTypeOptions/nosniff-importScript-blocked.html [ Pass Timeout ]
> 
> webkit.org/b/181100 inspector/worker/worker-recover-if-inspector-close.html [ Pass Failure ]
>+
>diff --git a/LayoutTests/imported/w3c/resources/resource-files.json b/LayoutTests/imported/w3c/resources/resource-files.json
>index 3c4f1ac2f5b42d97a18757ccb3b43a22e7c77998..ce605d91b2dcdd640c4558d36aaeb0c46de3701b 100644
>--- a/LayoutTests/imported/w3c/resources/resource-files.json
>+++ b/LayoutTests/imported/w3c/resources/resource-files.json
>@@ -22,18 +22,138 @@
>         "web-platform-tests/FileAPI/support/url-origin.html",
>         "web-platform-tests/XMLHttpRequest/xmlhttprequest-sync-block-defer-scripts-subframe.html",
>         "web-platform-tests/XMLHttpRequest/xmlhttprequest-sync-not-hang-scriptloader-subframe.html",
>+        "web-platform-tests/acid/acid2/404.html",
>+        "web-platform-tests/acid/acid2/test.html",
>+        "web-platform-tests/acid/acid3/empty.html",
>+        "web-platform-tests/acid/acid3/empty.xml",
>+        "web-platform-tests/acid/acid3/svg.xml",
>         "web-platform-tests/beacon/fetch-keepalive-navigate.iFrame.html",
>         "web-platform-tests/beacon/navigate.iFrame.sub.html",
>+        "web-platform-tests/credential-management/support/echoing-nester.html",
>+        "web-platform-tests/credential-management/support/federatedcredential-get.html",
>+        "web-platform-tests/credential-management/support/passwordcredential-get.html",
>         "web-platform-tests/css/WOFF2/available-001.xht",
>+        "web-platform-tests/css/WOFF2/available-002.xht",
>         "web-platform-tests/css/WOFF2/support/available-001a.xht",
>         "web-platform-tests/css/WOFF2/support/available-001b.xht",
>         "web-platform-tests/css/WOFF2/testcaseindex.xht",
>+        "web-platform-tests/css/css-color/t32-opacity-basic-0.6-a.xht",
>+        "web-platform-tests/css/css-color/t32-opacity-zorder-c.xht",
>+        "web-platform-tests/css/css-color/t421-rgb-hex3-expand-b.xht",
>+        "web-platform-tests/css/css-color/t422-rgba-a0.6-a.xht",
>+        "web-platform-tests/css/css-color/t425-hsla-basic-a.xht",
>+        "web-platform-tests/css/css-display/run-in/after-content-display-004.xht",
>+        "web-platform-tests/css/css-display/run-in/anonymous-box-generation-002.xht",
>+        "web-platform-tests/css/css-display/run-in/background-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/background-attachment-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/background-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/background-image-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/background-position-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/background-repeat-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/before-content-display-004.xht",
>+        "web-platform-tests/css/css-display/run-in/border-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-bottom-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-bottom-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-bottom-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-bottom-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-collapse-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/border-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-left-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-left-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-left-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-left-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-right-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-right-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-right-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-right-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-spacing-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/border-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-top-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-top-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-top-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-top-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/border-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/bottom-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/caption-side-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/clear-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/clear-runin-001.xht",
>+        "web-platform-tests/css/css-display/run-in/color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/direction-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/display-004.xht",
>+        "web-platform-tests/css/css-display/run-in/empty-cells-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/first-line-pseudo-009.xht",
>+        "web-platform-tests/css/css-display/run-in/float-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/font-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/font-family-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/font-size-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/left-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/line-height-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/list-style-image-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/list-style-position-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/margin-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/margin-bottom-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/margin-left-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/margin-right-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/margin-top-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/outline-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/outline-color-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/outline-style-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/outline-width-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/overflow-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/padding-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/padding-bottom-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/padding-left-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/padding-right-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/padding-top-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/position-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/right-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-001.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-002.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-003.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-004.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-005.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-006.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-007.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-008.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-009.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-010.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-011.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-012.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-013.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-inheritance-001.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-linebox-001.xht",
>+        "web-platform-tests/css/css-display/run-in/run-in-linebox-002.xht",
>+        "web-platform-tests/css/css-display/run-in/table-anonymous-block-001.xht",
>+        "web-platform-tests/css/css-display/run-in/table-layout-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/text-align-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/text-indent-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/top-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/unicode-bidi-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/vertical-align-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/visibility-applies-to-011.xht",
>+        "web-platform-tests/css/css-display/run-in/white-space-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/word-spacing-applies-to-004.xht",
>+        "web-platform-tests/css/css-display/run-in/z-index-applies-to-011.xht",
>         "web-platform-tests/css/css-grid-1/grid-items/ref-filled-green-100px-square-image.html",
>         "web-platform-tests/css/css-grid-1/test-plan/index.html",
>         "web-platform-tests/css/css-grid/grid-items/ref-filled-green-100px-square-image.html",
>         "web-platform-tests/css/css-grid/test-plan/index.html",
>         "web-platform-tests/css/css-multicol/multicol-rule-large-002.xht",
>+        "web-platform-tests/css/css-pseudo/placeholder-input-number-notref.html",
>         "web-platform-tests/css/css-shapes/test-plan/index.html",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-001.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-002.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-003.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-004.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-005.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-006.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-007.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-008.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-009.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-010.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-011.xht",
>+        "web-platform-tests/css/css-text-decor/text-decoration-visibility-012.xht",
>+        "web-platform-tests/css/css-text-decor/text-emphasis-style-016.html",
>         "web-platform-tests/css/css-text/text-align/text-align-end-018.html",
>         "web-platform-tests/css/css-text/text-align/text-align-end-019.html",
>         "web-platform-tests/css/css-text/text-align/text-align-end-020.html",
>@@ -310,9 +430,311 @@
>         "web-platform-tests/css/css-ui/support/nav-up-013-frame.html",
>         "web-platform-tests/css/css-ui/text-overflow-018.html",
>         "web-platform-tests/css/css-ui/text-overflow-019.html",
>+        "web-platform-tests/css/cssom-view/iframe.html",
>         "web-platform-tests/css/cssom/support/xmlss-pi.xhtml",
>+        "web-platform-tests/css/mediaqueries/media-queries-001.xht",
>+        "web-platform-tests/css/mediaqueries/media-queries-002.xht",
>+        "web-platform-tests/css/mediaqueries/media-queries-003.xht",
>         "web-platform-tests/css/mediaqueries/support/media_queries_iframe.html",
>         "web-platform-tests/css/mediaqueries/support/min-width-tables-001-iframe.html",
>+        "web-platform-tests/css/selectors/css3-modsel-1.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-10.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-100.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-100b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-101.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-101b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-102.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-102b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-103.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-103b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-104.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-104b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-105.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-105b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-106.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-106b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-107.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-107b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-108.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-108b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-109.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-109b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-11.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-110.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-110b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-111.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-111b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-112.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-112b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-113.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-113b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-114.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-114b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-115.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-115b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-116.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-116b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-117.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-117b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-118.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-119.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-120.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-121.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-122.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-123.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-123b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-124.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-124b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-125.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-125b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-126.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-126b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-127.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-127b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-128.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-128b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-129.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-129b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-13.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-130.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-130b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-131.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-131b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-132.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-132b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-133.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-133b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-134.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-134b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-135.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-135b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-136.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-136b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-137.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-137b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-138.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-138b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-139.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-139b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-14.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-140.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-140b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-141.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-141b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-142.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-142b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-143.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-143b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-144.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-145a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-145b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-146a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-146b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-147a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-147b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-148.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-149.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-149b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-14b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-14c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-14d.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-14e.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-15.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-150.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-151.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-152.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-153.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-154.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-155.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-155a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-155b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-155c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-155d.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-156.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-156b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-156c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-157.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-158.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-159.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-15b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-15c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-16.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-160.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-161.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-166.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-166a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-167.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-167a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-168.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-168a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-169.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-169a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-17.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-170.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-170a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-170b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-170c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-170d.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-171.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-172a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-172b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-173a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-173b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-174a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-174b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-175a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-175b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-175c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-176.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-177a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-177b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-178.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-179.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-179a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-18.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-180a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-181.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-182.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-183.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184d.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184e.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-184f.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-18a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-18b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-18c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-19.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-19b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-2.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-20.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-21.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-21b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-21c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-22.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-23.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-24.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-25.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-27.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-27a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-27b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-28.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-28b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-29.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-29b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-3.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-30.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-31.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-32.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-33.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-34.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-35.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-36.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-37.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-38.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-39.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-39a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-39b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-39c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-3a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-4.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-41.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-41a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-42.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-42a.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-43.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-43b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-44.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-44b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-44c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-44d.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-45.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-45b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-45c.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-46.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-46b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-47.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-48.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-49.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-5.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-50.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-51.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-52.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-53.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-54.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-55.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-56.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-57.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-57b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-59.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-6.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-60.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-61.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-62.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-63.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-64.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-65.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-66.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-66b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-67.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-68.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-69.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-7.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-70.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-72.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-72b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-73.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-73b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-74.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-74b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-75.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-75b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-76.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-76b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-77.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-77b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-78.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-78b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-79.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-7b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-8.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-80.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-81.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-81b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-82.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-82b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-83.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-86.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-87.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-87b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-88.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-88b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-89.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-9.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-90.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-90b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-91.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-92.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-93.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-94.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-94b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-95.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-96.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-96b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-97.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-97b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-98.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-98b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-99.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-99b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-d1.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-d1b.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-d2.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-d3.xml",
>+        "web-platform-tests/css/selectors/css3-modsel-d4.xml",
>+        "web-platform-tests/css/selectors/selection-image-001-no-selection-noref.html",
>+        "web-platform-tests/css/selectors/selection-image-001-noref.html",
>         "web-platform-tests/cssom-view/iframe.html",
>         "web-platform-tests/cssom/support/xmlss-pi.xhtml",
>         "web-platform-tests/dom/events/EventListener-incumbent-global-subframe-1.sub.html",
>@@ -325,7 +747,15 @@
>         "web-platform-tests/dom/nodes/ParentNode-querySelector-All-content.html",
>         "web-platform-tests/dom/nodes/ParentNode-querySelector-All-content.xht",
>         "web-platform-tests/dom/nodes/getElementsByClassNameFrame.htm",
>+        "web-platform-tests/dom/nodes/query-target-in-load-event.part.html",
>         "web-platform-tests/dom/ranges/Range-test-iframe.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/euc-jp/eucjp_chars-cseucpkdfmtjapanese.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/euc-jp/eucjp_chars-x-euc-jp.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/euc-jp/eucjp_chars.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/euc-jp/eucjp_errors.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/iso-2022-jp/iso2022jp_chars-csiso2022jp.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/iso-2022-jp/iso2022jp_chars.html",
>+        "web-platform-tests/encoding/legacy-mb-japanese/iso-2022-jp/iso2022jp_errors.html",
>         "web-platform-tests/encoding/legacy-mb-japanese/shift_jis/sjis_chars-csshiftjis.html",
>         "web-platform-tests/encoding/legacy-mb-japanese/shift_jis/sjis_chars-ms932.html",
>         "web-platform-tests/encoding/legacy-mb-japanese/shift_jis/sjis_chars-ms_kanji.html",
>@@ -482,11 +912,19 @@
>         "web-platform-tests/html/browsers/history/the-session-history-of-browsing-contexts/navigation-in-onload_form-submission-2.tentative.html",
>         "web-platform-tests/html/browsers/history/the-session-history-of-browsing-contexts/navigation-in-onload_form-submission-dynamic-iframe.tentative.html",
>         "web-platform-tests/html/browsers/history/the-session-history-of-browsing-contexts/navigation-in-onload_form-submission-iframe.tentative.html",
>+        "web-platform-tests/html/browsers/offline/browser-state/navigator_online_event-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/manifest_main_empty-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/manifest_notchanged_online-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/manifest_section_empty-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/manifest_section_many-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/section_network_offline-manual.https.html",
>+        "web-platform-tests/html/browsers/offline/section_network_online-manual.https.html",
>         "web-platform-tests/html/browsers/origin/cross-origin-objects/frame-with-then.html",
>         "web-platform-tests/html/browsers/origin/cross-origin-objects/frame.html",
>         "web-platform-tests/html/browsers/origin/cross-origin-objects/win-documentdomain.sub.html",
>         "web-platform-tests/html/browsers/origin/relaxing-the-same-origin-restriction/document_domain_setter_iframe.html",
>         "web-platform-tests/html/browsers/origin/relaxing-the-same-origin-restriction/support/document_domain_frame.html",
>+        "web-platform-tests/html/browsers/origin/relaxing-the-same-origin-restriction/support/document_domain_setter_iframe.html",
>         "web-platform-tests/html/browsers/sandboxing/inner-iframe.html",
>         "web-platform-tests/html/browsers/the-window-object/accessing-other-browsing-contexts/test1.html",
>         "web-platform-tests/html/browsers/the-window-object/accessing-other-browsing-contexts/test2.html",
>@@ -595,6 +1033,7 @@
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/iframe_sandbox_029.htm",
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/iframe_sandbox_031.htm",
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/iframe_sandbox_032.htm",
>+        "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/load-into-the-iframe.html",
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/navigation-changed-iframe.html",
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/sandbox_allow_script.html",
>         "web-platform-tests/html/semantics/embedded-content/the-iframe-element/support/standalone-fail.htm",
>@@ -662,6 +1101,9 @@
>         "web-platform-tests/secure-contexts/support/https-subframe-dedicated.html",
>         "web-platform-tests/secure-contexts/support/https-subframe-shared.html",
>         "web-platform-tests/secure-contexts/support/shared-worker-insecure-popup.html",
>+        "web-platform-tests/service-workers/service-worker/fetch-event-is-history-backward-navigation-manual.https.html",
>+        "web-platform-tests/service-workers/service-worker/fetch-event-is-history-forward-navigation-manual.https.html",
>+        "web-platform-tests/service-workers/service-worker/fetch-event-is-reload-navigation-manual.https.html",
>         "web-platform-tests/service-workers/service-worker/multi-globals/current/current.https.html",
>         "web-platform-tests/service-workers/service-worker/multi-globals/incumbent/incumbent.https.html",
>         "web-platform-tests/service-workers/service-worker/multi-globals/relevant/relevant.https.html",
>@@ -680,6 +1122,9 @@
>         "web-platform-tests/workers/semantics/xhr/001-1.xml",
>         "web-platform-tests/workers/semantics/xhr/support/001-1.xml",
>         "web-platform-tests/workers/support/WorkerLocation-origin.html",
>-        "web-platform-tests/workers/support/sandboxed-tests.html"
>+        "web-platform-tests/workers/support/iframe_sw_dataUrl.html",
>+        "web-platform-tests/workers/support/sandboxed-tests.html",
>+        "web-platform-tests/xhr/xmlhttprequest-sync-block-defer-scripts-subframe.html",
>+        "web-platform-tests/xhr/xmlhttprequest-sync-not-hang-scriptloader-subframe.html"
>     ]
> }
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html b/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html
>index ebda395b758387e868092dcc9be6ed8ea53dfffd..030263472a36c76f7ce15256187a658ed6b77cf7 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html
>@@ -8,20 +8,19 @@
> <script src="common.sub.js"></script>
> <div id=log></div>
> <script>
>-let worker, tests = {};
>+let worker, continuations = {};
> setup(function() {
>     worker = new Worker("transfer-worker.js");
>     worker.addEventListener("message", function(event) {
>         let { name, bitmap } = event.data;
>-        tests[name](bitmap);
>+        if (continuations.hasOwnProperty(name)) {
>+            continuations[name](bitmap);
>+        }
>     });
> });
> 
> for (let { name, factory } of imageSourceTypes) {
>     promise_test(function(t) {
>-        let message_handler = new Promise(function(resolve) {
>-            tests[t.name] = resolve;
>-        });
>         return factory().then(createImageBitmap).then(function(bitmap) {
>             assert_equals(bitmap.width, 20);
>             assert_equals(bitmap.height, 20);
>@@ -31,7 +30,9 @@ for (let { name, factory } of imageSourceTypes) {
>             assert_equals(bitmap.width, 0);
>             assert_equals(bitmap.height, 0);
> 
>-            return message_handler;
>+            return new Promise(function(resolve) {
>+                continuations[t.name] = resolve;
>+            });
>         }).then(function(bitmap) {
>             assert_class_string(bitmap, "ImageBitmap");
>             assert_equals(bitmap.width, 20);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/w3c-import.log
>index 01be627bd3fc28cbc68a98482bb4fec8bcff36de..c8b42711cf724d1982fedbb58c7143136e002f18 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/w3c-import.log
>@@ -19,3 +19,5 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-invalid-args.html
> /LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-origin.sub.html
> /LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-sizeOverflow.html
>+/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/createImageBitmap-transfer.html
>+/LayoutTests/imported/w3c/web-platform-tests/2dcontext/imagebitmap/transfer-worker.js
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/file_test2.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/file_test2.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/w3c-import.log
>index 06ae8c12c3a6fd0e05dae873053ffbb1edc97ea8..d58eaac94f97d6fab44a4d33507440cb935a9f2b 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/w3c-import.log
>@@ -14,6 +14,4 @@ Property values requiring vendor prefixes:
> None
> ------------------------------------------------------------------------
> List of files:
>-/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/file_test1.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/file_test2.txt
>-/LayoutTests/imported/w3c/web-platform-tests/FileAPI/BlobURL/support/file_test3.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/support/file_test1.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/support/file_test1.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..c1c8d1a05172bafd030faffeebb26a11348158f4
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers-expected.txt
>@@ -0,0 +1,6 @@
>+CONSOLE MESSAGE: line 7: InvalidStateError: The object is in an invalid state.
>+
>+Harness Error (FAIL), message = InvalidStateError: The object is in an invalid state.
>+
>+TIMEOUT FileReader created after a worker self.close() Test timed out
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..8e114eeaf86ff55e6944bff0b17a099f6d8a02f8
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/FileReader/workers.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE html>
>+<meta charset=utf-8>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+
>+async_test(t => {
>+  function workerCode() {
>+    close();
>+    var blob = new Blob([123]);
>+    var fr = new FileReader();
>+    fr.readAsText(blob);
>+    fr.abort()
>+    fr.readAsArrayBuffer(blob);
>+    postMessage(true);
>+  }
>+
>+  var workerBlob = new Blob([workerCode.toString() + ";workerCode();"], {type:"application/javascript"});
>+
>+  var w = new Worker(URL.createObjectURL(workerBlob));
>+  w.onmessage = function(e) {
>+    assert_true(e.data, "FileReader created during worker shutdown.");
>+    t.done();
>+  }
>+}, 'FileReader created after a worker self.close()');
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1e0a15d3fd9f0548101a556c9c62b66b1860b29f
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings-expected.txt
>@@ -0,0 +1,47 @@
>+
>+PASS Valid "endings" value: "transparent" 
>+PASS Valid "endings" value: "native" 
>+PASS Invalid "endings" value: null 
>+PASS Invalid "endings" value: "" 
>+PASS Invalid "endings" value: "invalidEnumValue" 
>+PASS Invalid "endings" value: "Transparent" 
>+PASS Invalid "endings" value: "NATIVE" 
>+PASS Invalid "endings" value: 0 
>+PASS Invalid "endings" value: {} 
>+PASS Exception propagation from options 
>+PASS The "endings" options property is used 
>+PASS Input LF with endings unspecified 
>+PASS Input LF with endings 'transparent' 
>+PASS Input LF with endings 'native' 
>+PASS Input CR with endings unspecified 
>+PASS Input CR with endings 'transparent' 
>+PASS Input CR with endings 'native' 
>+PASS Input CRLF with endings unspecified 
>+PASS Input CRLF with endings 'transparent' 
>+PASS Input CRLF with endings 'native' 
>+PASS Input CRCR with endings unspecified 
>+PASS Input CRCR with endings 'transparent' 
>+PASS Input CRCR with endings 'native' 
>+PASS Input LFCR with endings unspecified 
>+PASS Input LFCR with endings 'transparent' 
>+PASS Input LFCR with endings 'native' 
>+PASS Input LFLF with endings unspecified 
>+PASS Input LFLF with endings 'transparent' 
>+PASS Input LFLF with endings 'native' 
>+PASS Input CRCRLF with endings unspecified 
>+PASS Input CRCRLF with endings 'transparent' 
>+PASS Input CRCRLF with endings 'native' 
>+PASS Input CRLFLF with endings unspecified 
>+PASS Input CRLFLF with endings 'transparent' 
>+PASS Input CRLFLF with endings 'native' 
>+PASS Input CRLFCR with endings unspecified 
>+PASS Input CRLFCR with endings 'transparent' 
>+PASS Input CRLFCR with endings 'native' 
>+PASS Input CRLFCRLF with endings unspecified 
>+PASS Input CRLFCRLF with endings 'transparent' 
>+PASS Input CRLFCRLF with endings 'native' 
>+PASS Input LFCRLFCR with endings unspecified 
>+PASS Input LFCRLFCR with endings 'transparent' 
>+PASS Input LFCRLFCR with endings 'native' 
>+PASS CR/LF in adjacent input strings 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..1dee99ff775da3562194719be06b711c246b30ef
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings.html
>@@ -0,0 +1,104 @@
>+<!DOCTYPE html>
>+<meta charset=utf-8>
>+<title>Blob constructor: endings option</title>
>+<link rel=help href="https://w3c.github.io/FileAPI/#constructorBlob">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+
>+// Windows platforms use CRLF as the native line ending. All others use LF.
>+const crlf = navigator.platform.startsWith('Win');
>+const native_ending = crlf ? '\r\n' : '\n';
>+
>+function readBlobAsPromise(blob) {
>+  return new Promise((resolve, reject) => {
>+    const reader = new FileReader();
>+    reader.readAsText(blob);
>+    reader.onload = e => resolve(reader.result);
>+    reader.onerror = e => reject(reader.error);
>+  });
>+}
>+
>+[
>+  'transparent',
>+  'native'
>+].forEach(value => test(t => {
>+  assert_class_string(new Blob([], {endings: value}), 'Blob',
>+                      `Constructor should allow "${value}" endings`);
>+}, `Valid "endings" value: ${JSON.stringify(value)}`));
>+
>+[
>+  null,
>+  '',
>+  'invalidEnumValue',
>+  'Transparent',
>+  'NATIVE',
>+  0,
>+  {}
>+].forEach(value => test(t => {
>+  assert_throws(new TypeError(), () => new Blob([], {endings: value}),
>+                'Blob constructor should throw');
>+}, `Invalid "endings" value: ${JSON.stringify(value)}`));
>+
>+test(t => {
>+  const test_error = {name: 'test'};
>+  assert_throws(
>+    test_error,
>+    () => new Blob([], { get endings() { throw test_error; }}),
>+    'Blob constructor should propagate exceptions from "endings" property');
>+}, 'Exception propagation from options');
>+
>+test(t => {
>+  let got = false;
>+  new Blob([], { get endings() { got = true; } });
>+  assert_true(got, 'The "endings" property was accessed during construction.');
>+}, 'The "endings" options property is used');
>+
>+[
>+  {name: 'LF', input: '\n', native: native_ending},
>+  {name: 'CR', input: '\r', native: native_ending},
>+
>+  {name: 'CRLF', input: '\r\n', native: native_ending},
>+  {name: 'CRCR', input: '\r\r', native: native_ending.repeat(2)},
>+  {name: 'LFCR', input: '\n\r', native: native_ending.repeat(2)},
>+  {name: 'LFLF', input: '\n\n', native: native_ending.repeat(2)},
>+
>+  {name: 'CRCRLF', input: '\r\r\n', native: native_ending.repeat(2)},
>+  {name: 'CRLFLF', input: '\r\n\n', native: native_ending.repeat(2)},
>+  {name: 'CRLFCR', input: '\r\n\r\n', native: native_ending.repeat(2)},
>+
>+  {name: 'CRLFCRLF', input: '\r\n\r\n', native: native_ending.repeat(2)},
>+  {name: 'LFCRLFCR', input: '\n\r\n\r', native: native_ending.repeat(3)},
>+
>+].forEach(testCase => {
>+  promise_test(async t => {
>+    const blob = new Blob([testCase.input]);
>+    assert_equals(
>+      await readBlobAsPromise(blob), testCase.input,
>+      'Newlines should not change with endings unspecified');
>+  }, `Input ${testCase.name} with endings unspecified`);
>+
>+  promise_test(async t => {
>+    const blob = new Blob([testCase.input], {endings: 'transparent'});
>+    assert_equals(
>+      await readBlobAsPromise(blob), testCase.input,
>+      'Newlines should not change with endings "transparent"');
>+  }, `Input ${testCase.name} with endings 'transparent'`);
>+
>+  promise_test(async t => {
>+    const blob = new Blob([testCase.input], {endings: 'native'});
>+    assert_equals(
>+      await readBlobAsPromise(blob), testCase.native,
>+      'Newlines should match the platform with endings "native"');
>+  }, `Input ${testCase.name} with endings 'native'`);
>+});
>+
>+promise_test(async t => {
>+  const blob = new Blob(['\r', '\n'], {endings: 'native'});
>+  const expected = native_ending.repeat(2);
>+  assert_equals(
>+    await readBlobAsPromise(blob), expected,
>+    'CR/LF in adjacent strings should be converted to two platform newlines');
>+}, `CR/LF in adjacent input strings`);
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/w3c-import.log
>index f81e3683fcf1b13e64dff774ea0f9e211a2cf692..9ae9f1d64ef2fb2f6e4472151f8527a7e423d945 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/w3c-import.log
>@@ -14,6 +14,7 @@ Property values requiring vendor prefixes:
> None
> ------------------------------------------------------------------------
> List of files:
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor-endings.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-constructor.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-in-worker.worker.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/blob/Blob-slice-overflow.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..01f97b7cf5060402a55ee341d5063f805442e3c6
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings-expected.txt
>@@ -0,0 +1,47 @@
>+
>+PASS Valid "endings" value: "transparent" 
>+PASS Valid "endings" value: "native" 
>+PASS Invalid "endings" value: null 
>+PASS Invalid "endings" value: "" 
>+PASS Invalid "endings" value: "invalidEnumValue" 
>+PASS Invalid "endings" value: "Transparent" 
>+PASS Invalid "endings" value: "NATIVE" 
>+PASS Invalid "endings" value: 0 
>+PASS Invalid "endings" value: {} 
>+PASS Exception propagation from options 
>+PASS The "endings" options property is used 
>+PASS Input LF with endings unspecified 
>+PASS Input LF with endings 'transparent' 
>+PASS Input LF with endings 'native' 
>+PASS Input CR with endings unspecified 
>+PASS Input CR with endings 'transparent' 
>+FAIL Input CR with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n" but got "\r"
>+PASS Input CRLF with endings unspecified 
>+PASS Input CRLF with endings 'transparent' 
>+FAIL Input CRLF with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n" but got "\r\n"
>+PASS Input CRCR with endings unspecified 
>+PASS Input CRCR with endings 'transparent' 
>+FAIL Input CRCR with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\r\r"
>+PASS Input LFCR with endings unspecified 
>+PASS Input LFCR with endings 'transparent' 
>+FAIL Input LFCR with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\n\r"
>+PASS Input LFLF with endings unspecified 
>+PASS Input LFLF with endings 'transparent' 
>+PASS Input LFLF with endings 'native' 
>+PASS Input CRCRLF with endings unspecified 
>+PASS Input CRCRLF with endings 'transparent' 
>+FAIL Input CRCRLF with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\r\r\n"
>+PASS Input CRLFLF with endings unspecified 
>+PASS Input CRLFLF with endings 'transparent' 
>+FAIL Input CRLFLF with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\r\n\n"
>+PASS Input CRLFCR with endings unspecified 
>+PASS Input CRLFCR with endings 'transparent' 
>+FAIL Input CRLFCR with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\r\n\r\n"
>+PASS Input CRLFCRLF with endings unspecified 
>+PASS Input CRLFCRLF with endings 'transparent' 
>+FAIL Input CRLFCRLF with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n" but got "\r\n\r\n"
>+PASS Input LFCRLFCR with endings unspecified 
>+PASS Input LFCRLFCR with endings 'transparent' 
>+FAIL Input LFCRLFCR with endings 'native' assert_equals: Newlines should match the platform with endings "native" expected "\n\n\n" but got "\n\r\n\r"
>+FAIL CR/LF in adjacent input strings assert_equals: CR/LF in adjacent strings should be converted to two platform newlines expected "\n\n" but got "\r\n"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..f0f9090768f48e25fb7fd47e5cd182bf11f065e4
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/File-constructor-endings.html
>@@ -0,0 +1,104 @@
>+<!DOCTYPE html>
>+<meta charset=utf-8>
>+<title>File constructor: endings option</title>
>+<link rel=help href="https://w3c.github.io/FileAPI/#file-constructor">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+
>+// Windows platforms use CRLF as the native line ending. All others use LF.
>+const crlf = navigator.platform.startsWith('Win');
>+const native_ending = crlf ? '\r\n' : '\n';
>+
>+function readBlobAsPromise(blob) {
>+  return new Promise((resolve, reject) => {
>+    const reader = new FileReader();
>+    reader.readAsText(blob);
>+    reader.onload = e => resolve(reader.result);
>+    reader.onerror = e => reject(reader.error);
>+  });
>+}
>+
>+[
>+  'transparent',
>+  'native'
>+].forEach(value => test(t => {
>+  assert_class_string(new File([], "name", {endings: value}), 'File',
>+                      `Constructor should allow "${value}" endings`);
>+}, `Valid "endings" value: ${JSON.stringify(value)}`));
>+
>+[
>+  null,
>+  '',
>+  'invalidEnumValue',
>+  'Transparent',
>+  'NATIVE',
>+  0,
>+  {}
>+].forEach(value => test(t => {
>+  assert_throws(new TypeError(), () => new File([], "name", {endings: value}),
>+                'File constructor should throw');
>+}, `Invalid "endings" value: ${JSON.stringify(value)}`));
>+
>+test(t => {
>+  const test_error = {name: 'test'};
>+  assert_throws(
>+    test_error,
>+    () => new File([], "name", { get endings() { throw test_error; }}),
>+    'File constructor should propagate exceptions from "endings" property');
>+}, 'Exception propagation from options');
>+
>+test(t => {
>+  let got = false;
>+  new File([], "name", { get endings() { got = true; } });
>+  assert_true(got, 'The "endings" property was accessed during construction.');
>+}, 'The "endings" options property is used');
>+
>+[
>+  {name: 'LF', input: '\n', native: native_ending},
>+  {name: 'CR', input: '\r', native: native_ending},
>+
>+  {name: 'CRLF', input: '\r\n', native: native_ending},
>+  {name: 'CRCR', input: '\r\r', native: native_ending.repeat(2)},
>+  {name: 'LFCR', input: '\n\r', native: native_ending.repeat(2)},
>+  {name: 'LFLF', input: '\n\n', native: native_ending.repeat(2)},
>+
>+  {name: 'CRCRLF', input: '\r\r\n', native: native_ending.repeat(2)},
>+  {name: 'CRLFLF', input: '\r\n\n', native: native_ending.repeat(2)},
>+  {name: 'CRLFCR', input: '\r\n\r\n', native: native_ending.repeat(2)},
>+
>+  {name: 'CRLFCRLF', input: '\r\n\r\n', native: native_ending.repeat(2)},
>+  {name: 'LFCRLFCR', input: '\n\r\n\r', native: native_ending.repeat(3)},
>+
>+].forEach(testCase => {
>+  promise_test(async t => {
>+    const file = new File([testCase.input], "name");
>+    assert_equals(
>+      await readBlobAsPromise(file), testCase.input,
>+      'Newlines should not change with endings unspecified');
>+  }, `Input ${testCase.name} with endings unspecified`);
>+
>+  promise_test(async t => {
>+    const file = new File([testCase.input], "name", {endings: 'transparent'});
>+    assert_equals(
>+      await readBlobAsPromise(file), testCase.input,
>+      'Newlines should not change with endings "transparent"');
>+  }, `Input ${testCase.name} with endings 'transparent'`);
>+
>+  promise_test(async t => {
>+    const file = new File([testCase.input], "name", {endings: 'native'});
>+    assert_equals(
>+      await readBlobAsPromise(file), testCase.native,
>+      'Newlines should match the platform with endings "native"');
>+  }, `Input ${testCase.name} with endings 'native'`);
>+});
>+
>+promise_test(async t => {
>+  const file = new File(['\r', '\n'], "name", {endings: 'native'});
>+  const expected = native_ending.repeat(2);
>+  assert_equals(
>+    await readBlobAsPromise(file), expected,
>+    'CR/LF in adjacent strings should be converted to two platform newlines');
>+}, `CR/LF in adjacent input strings`);
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b0de1ca6d1d1c05994f257a30e050468e037b98d
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-expected.txt
>@@ -0,0 +1,3 @@
>+
>+FAIL Upload file-for-upload-in-form.txt (ASCII) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a3e5b183a04f1de9ee7079d869f3ead669c520d1
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative-expected.txt
>@@ -0,0 +1,8 @@
>+
>+FAIL Upload file-for-upload-in-form.txt (ASCII) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ï°ïïï .txt (x-user-defined) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt (windows-1252) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âæâ.txt (JIS X 0201 and JIS X 0208) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âºð.txt (Unicode) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ABC~â¾Â¥âÂ¤ï½¥ã»â¢âÂ·â¼âæðæââ¼Â·ââ¢ã»ï½¥Â¤âÂ¥â¾~XYZ.txt (Unicode) in ISO-2022-JP form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..421de301298ba55a70124290066eaf66e6416394
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-iso-2022-jp.tentative.html
>@@ -0,0 +1,71 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Upload files in ISO-2022-JP form (tentative)</title>
>+
>+<link rel="help"
>+      href="https://github.com/whatwg/html/issues/3223">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
>+<link rel="help"
>+      href="https://w3c.github.io/FileAPI/#file-constructor">
>+<link rel="author" title="Benjamin C. Wiley Sittler"
>+      href="mailto:bsittler@chromium.org">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="../support/send-file-form-helper.js"></script>
>+<script>
>+'use strict';
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'ASCII',
>+  fileBaseName: 'file-for-upload-in-form.txt',
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'x-user-defined',
>+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: (
>+      'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt'),
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'windows-1252',
>+  fileBaseName: 'file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt',
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: (
>+      'file-for-upload-in-form-&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'JIS X 0201 and JIS X 0208',
>+  fileBaseName: 'file-for-upload-in-form-âæâ.txt',
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-\x1B$B!z@1!z\x1B(B.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: 'file-for-upload-in-form-âºð.txt',
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
>+  formEncoding: 'ISO-2022-JP',
>+  expectedEncodedBaseName: `file-for-upload-in-form-${
>+      kTestFallbackIso2022jp
>+  }.txt`,
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..4601f0703d886e804e30b289ae3b7a4712ad4583
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8-expected.txt
>@@ -0,0 +1,8 @@
>+
>+FAIL Upload file-for-upload-in-form.txt (ASCII) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ï°ïïï .txt (x-user-defined) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt (windows-1252) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âæâ.txt (JIS X 0201 and JIS X 0208) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âºð.txt (Unicode) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ABC~â¾Â¥âÂ¤ï½¥ã»â¢âÂ·â¼âæðæââ¼Â·ââ¢ã»ï½¥Â¤âÂ¥â¾~XYZ.txt (Unicode) in UTF-8 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..03417ba72e4c2cccef3ff17f4e41bba76cc598bb
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-utf-8.html
>@@ -0,0 +1,61 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Upload files in UTF-8 form</title>
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
>+<link rel="help"
>+      href="https://w3c.github.io/FileAPI/#file-constructor">
>+<link rel="author" title="Benjamin C. Wiley Sittler"
>+      href="mailto:bsittler@chromium.org">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="../support/send-file-form-helper.js"></script>
>+<script>
>+'use strict';
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'ASCII',
>+  fileBaseName: 'file-for-upload-in-form.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'x-user-defined',
>+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: (
>+      'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt'),
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'windows-1252',
>+  fileBaseName: 'file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'JIS X 0201 and JIS X 0208',
>+  fileBaseName: 'file-for-upload-in-form-âæâ.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-âæâ.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: 'file-for-upload-in-form-âºð.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-âºð.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..016ab08ef099dbc3359b57d81d801322a0b1e549
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative-expected.txt
>@@ -0,0 +1,8 @@
>+
>+FAIL Upload file-for-upload-in-form.txt (ASCII) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ï°ïïï .txt (x-user-defined) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt (windows-1252) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âæâ.txt (JIS X 0201 and JIS X 0208) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âºð.txt (Unicode) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ABC~â¾Â¥âÂ¤ï½¥ã»â¢âÂ·â¼âæðæââ¼Â·ââ¢ã»ï½¥Â¤âÂ¥â¾~XYZ.txt (Unicode) in windows-1252 form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..8e9463f83aecb47ba1da1aa30d1903508e279937
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-windows-1252.tentative.html
>@@ -0,0 +1,70 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Upload files in Windows-1252 form (tentative)</title>
>+
>+<link rel="help"
>+      href="https://github.com/whatwg/html/issues/3223">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
>+<link rel="help"
>+      href="https://w3c.github.io/FileAPI/#file-constructor">
>+<link rel="author" title="Benjamin C. Wiley Sittler"
>+      href="mailto:bsittler@chromium.org">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="../support/send-file-form-helper.js"></script>
>+<script>
>+'use strict';
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'ASCII',
>+  fileBaseName: 'file-for-upload-in-form.txt',
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'x-user-defined',
>+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: (
>+      'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt'),
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'windows-1252',
>+  fileBaseName: 'file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt',
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-âºð.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'JIS X 0201 and JIS X 0208',
>+  fileBaseName: 'file-for-upload-in-form-âæâ.txt',
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: 'file-for-upload-in-form-âºð.txt',
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
>+  formEncoding: 'windows-1252',
>+  expectedEncodedBaseName: `file-for-upload-in-form-${
>+      kTestFallbackWindows1252
>+  }.txt`,
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..2a23123d225912e55bc3d0fee5f0e809d5bcfe6b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative-expected.txt
>@@ -0,0 +1,8 @@
>+
>+FAIL Upload file-for-upload-in-form.txt (ASCII) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ï°ïïï .txt (x-user-defined) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt (windows-1252) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âæâ.txt (JIS X 0201 and JIS X 0208) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-âºð.txt (Unicode) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+FAIL Upload file-for-upload-in-form-ABC~â¾Â¥âÂ¤ï½¥ã»â¢âÂ·â¼âæðæââ¼Â·ââ¢ã»ï½¥Â¤âÂ¥â¾~XYZ.txt (Unicode) in x-user-defined form promise_test: Unhandled rejection with value: object "TypeError: function is not a constructor (evaluating 'new DataTransfer')"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..072e3bb1e02ea0ccc0e5442c1cae316acb40ce30
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form-x-user-defined.tentative.html
>@@ -0,0 +1,70 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Upload files in x-user-defined form (tentative)</title>
>+
>+<link rel="help"
>+      href="https://github.com/whatwg/html/issues/3223">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
>+<link rel="help"
>+      href="https://w3c.github.io/FileAPI/#file-constructor">
>+<link rel="author" title="Benjamin C. Wiley Sittler"
>+      href="mailto:bsittler@chromium.org">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="../support/send-file-form-helper.js"></script>
>+<script>
>+'use strict';
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'ASCII',
>+  fileBaseName: 'file-for-upload-in-form.txt',
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'x-user-defined',
>+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-ð .txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'windows-1252',
>+  fileBaseName: 'file-for-upload-in-form-Ã¢ËÂºÃ°Å¸Ëâ.txt',
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: ('file-for-upload-in-form-' +
>+                            '&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'JIS X 0201 and JIS X 0208',
>+  fileBaseName: 'file-for-upload-in-form-âæâ.txt',
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: 'file-for-upload-in-form-âºð.txt',
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
>+});
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'Unicode',
>+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
>+  formEncoding: 'x-user-defined',
>+  expectedEncodedBaseName: `file-for-upload-in-form-${
>+      kTestFallbackXUserDefined
>+  }.txt`,
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..baa8d4286c5789c55168cebf5496982b20d06083
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/file/send-file-form.html
>@@ -0,0 +1,25 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Upload ASCII-named file in UTF-8 form</title>
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
>+<link rel="help"
>+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
>+<link rel="help"
>+      href="https://w3c.github.io/FileAPI/#file-constructor">
>+<link rel="author" title="Benjamin C. Wiley Sittler"
>+      href="mailto:bsittler@chromium.org">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="../support/send-file-form-helper.js"></script>
>+<script>
>+'use strict';
>+
>+formPostFileUploadTest({
>+  fileNameSource: 'ASCII',
>+  fileBaseName: 'file-for-upload-in-form.txt',
>+  formEncoding: 'UTF-8',
>+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https-expected.txt
>index 432b314af3ae4b980345667a23e0be008d7406f9..51c65c500b85efee9c68c01f3953f437b1876040 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https-expected.txt
>@@ -2,10 +2,14 @@
> PASS "toNativeLineEndings" should not be supported 
> FAIL "FileError" should not be supported assert_false: expected false got true
> PASS "FileException" should not be supported 
>+PASS "FileHandle" should not be supported 
>+PASS "FileRequest" should not be supported 
>+PASS "MutableFile" should not be supported 
> PASS Blob should not support slice prefixed 
> PASS BlobBuilder should not be supported. 
> PASS createFor method should not be supported 
> PASS Blob.close() should not be supported 
>+PASS File's lastModifiedDate should not be supported 
> PASS Service worker test setup 
> FAIL "FileReaderSync" should not be supported in service workers assert_false: expected false got true
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https.html
>index 9d78b5690fbbe7a377874e59473d32d654445310..4f841f1763945946a4e2445a85a23b5d4326c386 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https.html
>@@ -10,17 +10,20 @@
>  <body>
>   <div id="log"></div>
>   <script>
>-    test(function() {
>-        assert_false('toNativeLineEndings' in window);
>-    }, '"toNativeLineEndings" should not be supported');
>+    var removedFromWindow = [
>+        'toNativeLineEndings',
>+        'FileError',
>+        'FileException',
>+        'FileHandle',
>+        'FileRequest',
>+        'MutableFile',
>+    ];
> 
>-    test(function() {
>-        assert_false('FileError' in window);
>-    }, '"FileError" should not be supported');
>-
>-    test(function() {
>-        assert_false('FileException' in window);
>-    }, '"FileException" should not be supported');
>+    removedFromWindow.forEach(function(name) {
>+        test(function() {
>+            assert_false(name in window);
>+        }, '"' + name + '" should not be supported');
>+    });
> 
>     test(function() {
>         var b = new Blob();
>@@ -50,9 +53,13 @@
>         assert_false('isClosed' in Blob.prototype, 'isClosed in Blob.prototype');
>     }, 'Blob.close() should not be supported');
> 
>-    // Only add service worker test if service workers are actually supported.
>-    if (navigator.serviceWorker)
>-      service_worker_test('support/historical-serviceworker.js', 'Service worker test setup');
>+    test(() => {
>+      const f = new File([], "");
>+      assert_false("lastModifiedDate" in f);
>+      assert_false("lastModifiedDate" in File.prototype);
>+    }, "File's lastModifiedDate should not be supported");
>+
>+    service_worker_test('support/historical-serviceworker.js', 'Service worker test setup');
>   </script>
>  </body>
> </html>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads-expected.txt
>index 551b602ee41fac49dea6407ec34f86c255549959..349419822e7a356758e2f9722d3d8126d9717733 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads-expected.txt
>@@ -4,4 +4,5 @@ PASS test FileReader InvalidStateError exception for readAsDataURL
> PASS test FileReader InvalidStateError exception for readAsArrayBuffer 
> PASS test FileReader InvalidStateError exception in onloadstart event for readAsArrayBuffer 
> PASS test FileReader no InvalidStateError exception in loadend event handler for readAsArrayBuffer 
>+FAIL test abort and restart in onloadstart event for readAsText The object is in an invalid state.
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads.html
>index ca04f3c1819e88e74a4c2c4f8a738ad79321c544..310fa85a00d02732265f2b1c9c02f1c6dbc2504d 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/FileReader-multiple-reads.html
>@@ -70,4 +70,20 @@ async_test(function() {
>   reader.readAsArrayBuffer(blob_1)
>   assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
> }, 'test FileReader no InvalidStateError exception in loadend event handler for readAsArrayBuffer');
>+
>+async_test(function() {
>+  var blob_1 = new Blob([new Uint8Array(0x414141)]);
>+  var blob_2 = new Blob(['TEST000000002']);
>+  var reader = new FileReader();
>+  reader.onloadstart = this.step_func(function() {
>+    reader.abort();
>+    reader.onloadstart = null;
>+    reader.onloadend = this.step_func_done(function() {
>+      assert_equals('TEST000000002', reader.result);
>+    });
>+    reader.readAsText(blob_2);
>+  });
>+  reader.readAsText(blob_1);
>+}, 'test abort and restart in onloadstart event for readAsText');
>+
> </script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e8bb2ab3a8982742333e86ec55488d303a8ba12a
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString-expected.txt
>@@ -0,0 +1,3 @@
>+
>+FAIL FileAPI Test: filereader_readAsBinaryString assert_equals: expected 1 but got 2
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..b550e4d0a96dc7e407e960be1bf43b5115037907
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString.html
>@@ -0,0 +1,32 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>FileAPI Test: filereader_readAsBinaryString</title>
>+<link rel="author" title="Intel" href="http://www.intel.com">
>+<link rel="help" href="https://w3c.github.io/FileAPI/#readAsBinaryString">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+
>+async_test(t => {
>+  const blob = new Blob(["Ï"]);
>+  const reader = new FileReader();
>+
>+  reader.onload = t.step_func_done(() => {
>+    assert_equals(typeof reader.result, "string", "The result is string");
>+    assert_equals(reader.result.length, 2, "The result length is 2");
>+    assert_equals(reader.result, "\xcf\x83", "The result is \xcf\x83");
>+    assert_equals(reader.readyState, reader.DONE);
>+  });
>+
>+  reader.onloadstart = t.step_func(() => {
>+    assert_equals(reader.readyState, reader.LOADING);
>+  });
>+
>+  reader.onprogress = t.step_func(() => {
>+    assert_equals(reader.readyState, reader.LOADING);
>+  });
>+
>+  reader.readAsBinaryString(blob);
>+});
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/w3c-import.log
>index d6b9800cf722f74d32a53a2d3884baafb44052df..760e26223da47552bcb711bd517b95bd1b40ad8c 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/w3c-import.log
>@@ -20,6 +20,7 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_abort.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_error.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsArrayBuffer.html
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsBinaryString.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsDataURL.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readAsText.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/reading-data-section/filereader_readystate.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/send-file-form-helper.js b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/send-file-form-helper.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..a7522c7b08ebc2451637e91dbd6a07040af4939d
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/send-file-form-helper.js
>@@ -0,0 +1,249 @@
>+'use strict';
>+
>+// Rationale for this particular test character sequence, which is
>+// used in filenames and also in file contents:
>+//
>+// - ABC~ ensures the string starts with something we can read to
>+//   ensure it is from the correct source; ~ is used because even
>+//   some 1-byte otherwise-ASCII-like parts of ISO-2022-JP
>+//   interpret it differently.
>+// - â¾Â¥ are inside a single-byte range of ISO-2022-JP and help
>+//   diagnose problems due to filesystem encoding or locale
>+// - â is inside IBM437 and helps diagnose problems due to filesystem
>+//   encoding or locale
>+// - Â¤ is inside Latin-1 and helps diagnose problems due to
>+//   filesystem encoding or locale; it is also the "simplest" case
>+//   needing substitution in ISO-2022-JP
>+// - ï½¥ is inside a single-byte range of ISO-2022-JP in some variants
>+//   and helps diagnose problems due to filesystem encoding or locale;
>+//   on the web it is distinct when decoding but unified when encoding
>+// - ã» is inside a double-byte range of ISO-2022-JP and helps
>+//   diagnose problems due to filesystem encoding or locale
>+// - â¢ is inside Windows-1252 and helps diagnose problems due to
>+//   filesystem encoding or locale and also ensures these aren't
>+//   accidentally turned into e.g. control codes
>+// - â is inside IBM437 and helps diagnose problems due to filesystem
>+//   encoding or locale
>+// - Â· is inside Latin-1 and helps diagnose problems due to
>+//   filesystem encoding or locale and also ensures HTML named
>+//   character references (e.g. &middot;) are not used
>+// - â¼ is inside IBM437 shadowing C0 and helps diagnose problems due to
>+//   filesystem encoding or locale and also ensures these aren't
>+//   accidentally turned into e.g. control codes
>+// - â is inside ISO-2022-JP on a non-Kanji page and makes correct
>+//   output easier to spot
>+// - æ is inside ISO-2022-JP on a Kanji page and makes correct
>+//   output easier to spot
>+// - ð is outside the BMP and makes incorrect surrogate pair
>+//   substitution detectable and ensures substitutions work
>+//   correctly immediately after Kanji 2-byte ISO-2022-JP
>+// - æ repeated here ensures the correct codec state is used
>+//   after a non-BMP substitution
>+// - â repeated here also makes correct output easier to spot
>+// - â¼ is inside IBM437 shadowing C0 and helps diagnose problems due to
>+//   filesystem encoding or locale and also ensures these aren't
>+//   accidentally turned into e.g. control codes and also ensures
>+//   substitutions work correctly immediately after non-Kanji
>+//   2-byte ISO-2022-JP
>+// - Â· is inside Latin-1 and helps diagnose problems due to
>+//   filesystem encoding or locale and also ensures HTML named
>+//   character references (e.g. &middot;) are not used
>+// - â is inside IBM437 and helps diagnose problems due to filesystem
>+//   encoding or locale
>+// - â¢ is inside Windows-1252 and again helps diagnose problems
>+//   due to filesystem encoding or locale
>+// - ã» is inside a double-byte range of ISO-2022-JP and helps
>+//   diagnose problems due to filesystem encoding or locale
>+// - ï½¥ is inside a single-byte range of ISO-2022-JP in some variants
>+//   and helps diagnose problems due to filesystem encoding or locale;
>+//   on the web it is distinct when decoding but unified when encoding
>+// - Â¤ is inside Latin-1 and helps diagnose problems due to
>+//   filesystem encoding or locale; again it is a "simple"
>+//   substitution case
>+// - â is inside IBM437 and helps diagnose problems due to filesystem
>+//   encoding or locale
>+// - Â¥â¾ are inside a single-byte range of ISO-2022-JP and help
>+//   diagnose problems due to filesystem encoding or locale
>+// - ~XYZ ensures earlier errors don't lead to misencoding of
>+//   simple ASCII
>+//
>+// Overall the near-symmetry makes common I18N mistakes like
>+// off-by-1-after-non-BMP easier to spot. All the characters
>+// are also allowed in Windows Unicode filenames.
>+const kTestChars = 'ABC~â¾Â¥âÂ¤ï½¥ã»â¢âÂ·â¼âæðæââ¼Â·ââ¢ã»ï½¥Â¤âÂ¥â¾~XYZ';
>+
>+// NOTE: The expected interpretation of ISO-2022-JP according to
>+// https://encoding.spec.whatwg.org/#iso-2022-jp-encoder unifies
>+// single-byte and double-byte katakana.
>+const kTestFallbackIso2022jp =
>+      ('ABC~\x1B(J~\\âÂ¤\x1B$B!&!&\x1B(Bâ¢âÂ·â¼\x1B$B!z@1\x1B(Bð' +
>+       '\x1B$B@1!z\x1B(Bâ¼Â·ââ¢\x1B$B!&!&\x1B(BÂ¤â\x1B(J\\~\x1B(B~XYZ').replace(
>+             /[^\0-\x7F]/gu,
>+           x => `&#${x.codePointAt(0)};`);
>+
>+// NOTE: \uFFFD is used here to replace Windows-1252 bytes to match
>+// how we will see them in the reflected POST bytes in a frame using
>+// UTF-8 byte interpretation. The bytes will actually be intact, but
>+// this code cannot tell and does not really care.
>+const kTestFallbackWindows1252 =
>+      'ABC~â¾\xA5â\xA4ï½¥ã»\x95â\xB7â¼âæðæââ¼\xB7â\x95ã»ï½¥\xA4â\xA5â¾~XYZ'.replace(
>+            /[^\0-\xFF]/gu,
>+          x => `&#${x.codePointAt(0)};`).replace(/[\x80-\xFF]/g, '\uFFFD');
>+
>+const kTestFallbackXUserDefined =
>+      kTestChars.replace(/[^\0-\x7F]/gu, x => `&#${x.codePointAt(0)};`);
>+
>+// formPostFileUploadTest - verifies multipart upload structure and
>+// numeric character reference replacement for filenames, field names,
>+// and field values.
>+//
>+// Uses /fetch/api/resources/echo-content.py to echo the upload
>+// POST with UTF-8 byte interpretation, leading to the "UTF-8 goggles"
>+// behavior documented below for expectedEncodedBaseName when non-
>+// UTF-8-compatible byte sequences appear in the formEncoding-encoded
>+// uploaded data.
>+//
>+// Fields in the parameter object:
>+//
>+// - fileNameSource: purely explanatory and gives a clue about which
>+//   character encoding is the source for the non-7-bit-ASCII parts of
>+//   the fileBaseName, or Unicode if no smaller-than-Unicode source
>+//   contains all the characters. Used in the test name.
>+// - fileBaseName: the not-necessarily-just-7-bit-ASCII file basename
>+//   used for the constructed test file. Used in the test name.
>+// - formEncoding: the acceptCharset of the form used to submit the
>+//   test file. Used in the test name.
>+// - expectedEncodedBaseName: the expected formEncoding-encoded
>+//   version of fileBaseName with unencodable characters replaced by
>+//   numeric character references and non-7-bit-ASCII bytes seen
>+//   through UTF-8 goggles; subsequences not interpretable as UTF-8
>+//   have each byte represented here by \uFFFD REPLACEMENT CHARACTER.
>+const formPostFileUploadTest = ({
>+  fileNameSource,
>+  fileBaseName,
>+  formEncoding,
>+  expectedEncodedBaseName,
>+}) => {
>+  promise_test(async testCase => {
>+
>+    if (document.readyState !== 'complete') {
>+      await new Promise(resolve => addEventListener('load', resolve));
>+    }
>+
>+    const formTargetFrame = Object.assign(document.createElement('iframe'), {
>+      name: 'formtargetframe',
>+    });
>+    document.body.append(formTargetFrame);
>+    testCase.add_cleanup(() => {
>+      document.body.removeChild(formTargetFrame);
>+    });
>+
>+    const form = Object.assign(document.createElement('form'), {
>+      acceptCharset: formEncoding,
>+      action: '/fetch/api/resources/echo-content.py',
>+      method: 'POST',
>+      enctype: 'multipart/form-data',
>+      target: formTargetFrame.name,
>+    });
>+    document.body.append(form);
>+    testCase.add_cleanup(() => {
>+      document.body.removeChild(form);
>+    });
>+
>+    // Used to verify that the browser agrees with the test about
>+    // which form charset is used.
>+    form.append(Object.assign(document.createElement('input'), {
>+      type: 'hidden',
>+      name: '_charset_',
>+    }));
>+
>+    // Used to verify that the browser agrees with the test about
>+    // field value replacement and encoding independently of file system
>+    // idiosyncracies.
>+    form.append(Object.assign(document.createElement('input'), {
>+      type: 'hidden',
>+      name: 'filename',
>+      value: fileBaseName,
>+    }));
>+
>+    // Same, but with name and value reversed to ensure field names
>+    // get the same treatment.
>+    form.append(Object.assign(document.createElement('input'), {
>+      type: 'hidden',
>+      name: fileBaseName,
>+      value: 'filename',
>+    }));
>+
>+    const fileInput = Object.assign(document.createElement('input'), {
>+      type: 'file',
>+      name: 'file',
>+    });
>+    form.append(fileInput);
>+
>+    // Removes c:\fakepath\ or other pseudofolder and returns just the
>+    // final component of filePath; allows both / and \ as segment
>+    // delimiters.
>+    const baseNameOfFilePath = filePath => filePath.split(/[\/\\]/).pop();
>+    await new Promise(resolve => {
>+      const dataTransfer = new DataTransfer;
>+      dataTransfer.items.add(
>+          new File([kTestChars], fileBaseName, {type: 'text/plain'}));
>+      fileInput.files = dataTransfer.files;
>+      // For historical reasons .value will be prefixed with
>+      // c:\fakepath\, but the basename should match the file name
>+      // exposed through the newer .files[0].name API. This check
>+      // verifies that assumption.
>+      assert_equals(
>+          fileInput.files[0].name,
>+          baseNameOfFilePath(fileInput.value),
>+          `The basename of the field's value should match its files[0].name`);
>+      form.submit();
>+      formTargetFrame.onload = resolve;
>+    });
>+
>+    const formDataText = formTargetFrame.contentDocument.body.textContent;
>+    const formDataLines = formDataText.split('\n');
>+    if (formDataLines.length && !formDataLines[formDataLines.length - 1]) {
>+      --formDataLines.length;
>+    }
>+    assert_greater_than(
>+        formDataLines.length,
>+        2,
>+        `${fileBaseName}: multipart form data must have at least 3 lines: ${
>+             JSON.stringify(formDataText)
>+           }`);
>+    const boundary = formDataLines[0];
>+    assert_equals(
>+        formDataLines[formDataLines.length - 1],
>+        boundary + '--',
>+        `${fileBaseName}: multipart form data must end with ${boundary}--: ${
>+             JSON.stringify(formDataText)
>+           }`);
>+    const expectedText = [
>+      boundary,
>+      'Content-Disposition: form-data; name="_charset_"',
>+      '',
>+      formEncoding,
>+      boundary,
>+      'Content-Disposition: form-data; name="filename"',
>+      '',
>+      expectedEncodedBaseName,
>+      boundary,
>+      `Content-Disposition: form-data; name="${expectedEncodedBaseName}"`,
>+      '',
>+      'filename',
>+      boundary,
>+      `Content-Disposition: form-data; name="file"; ` +
>+          `filename="${expectedEncodedBaseName}"`,
>+      'Content-Type: text/plain',
>+      '',
>+      kTestChars,
>+      boundary + '--',
>+    ].join('\n');
>+    assert_true(
>+        formDataText.startsWith(expectedText),
>+        `Unexpected multipart-shaped form data received:\n${
>+             formDataText
>+           }\nExpected:\n${expectedText}`);
>+  }, `Upload ${fileBaseName} (${fileNameSource}) in ${formEncoding} form`);
>+};
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/w3c-import.log
>index 9966e38de1ac8d72c96263bc8080ba7f71f8ed1c..5345a3145fb893a6ba9011aff15daa11bde45472 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/w3c-import.log
>@@ -18,5 +18,6 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/document-domain-setter.sub.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/historical-serviceworker.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/incumbent.sub.html
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/send-file-form-helper.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/upload.txt
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/support/url-origin.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..96e8ab4209223aecb6cede963f3c2a10b93ce520
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode-expected.txt
>@@ -0,0 +1,6 @@
>+
>+FAIL Test that strings are not NFC normalized by Blob constructor assert_equals: String should not be normalized expected "á½¹" but got "Ï"
>+FAIL Test that strings are not NFC normalized by File constructor assert_equals: String should not be normalized expected "á½¹" but got "Ï"
>+PASS Test that unpaired surrogates are replaced by Blob constructor 
>+PASS Test that unpaired surrogates are replaced by File constructor 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode.html b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..ce3e3579d7c2c74c27d907ccd25c953588ef87f2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode.html
>@@ -0,0 +1,46 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>Blob/Unicode interaction: normalization and encoding</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+'use strict';
>+
>+const OMICRON_WITH_OXIA = '\u1F79'; // NFC normalized to U+3CC
>+const CONTAINS_UNPAIRED_SURROGATES = 'abc\uDC00def\uD800ghi';
>+const REPLACED = 'abc\uFFFDdef\uFFFDghi';
>+
>+function readBlobAsPromise(blob) {
>+  return new Promise((resolve, reject) => {
>+    const reader = new FileReader();
>+    reader.readAsText(blob);
>+    reader.onload = () => resolve(reader.result);
>+    reader.onerror = () => reject(reader.error);
>+  });
>+}
>+
>+promise_test(async t => {
>+  const blob = new Blob([OMICRON_WITH_OXIA]);
>+  const result = await readBlobAsPromise(blob);
>+  assert_equals(result, OMICRON_WITH_OXIA, 'String should not be normalized');
>+}, 'Test that strings are not NFC normalized by Blob constructor');
>+
>+promise_test(async t => {
>+  const file = new File([OMICRON_WITH_OXIA], 'name');
>+  const result = await readBlobAsPromise(file);
>+  assert_equals(result, OMICRON_WITH_OXIA, 'String should not be normalized');
>+}, 'Test that strings are not NFC normalized by File constructor');
>+
>+promise_test(async t => {
>+  const blob = new Blob([CONTAINS_UNPAIRED_SURROGATES]);
>+  const result = await readBlobAsPromise(blob);
>+  assert_equals(result, REPLACED, 'Unpaired surrogates should be replaced.');
>+}, 'Test that unpaired surrogates are replaced by Blob constructor');
>+
>+promise_test(async t => {
>+  const file = new File([CONTAINS_UNPAIRED_SURROGATES], 'name');
>+  const result = await readBlobAsPromise(file);
>+  assert_equals(result, REPLACED, 'Unpaired surrogates should be replaced.');
>+}, 'Test that unpaired surrogates are replaced by File constructor');
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/w3c-import.log
>new file mode 100644
>index 0000000000000000000000000000000000000000..a1bdb1b424da6ab1ddea7e37e68c53dec391b320
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/w3c-import.log
>@@ -0,0 +1,21 @@
>+The tests in this directory were imported from the W3C repository.
>+Do NOT modify these tests directly in WebKit.
>+Instead, create a pull request on the WPT github:
>+	https://github.com/w3c/web-platform-tests
>+
>+Then run the Tools/Scripts/import-w3c-tests in WebKit to reimport
>+
>+Do NOT modify or remove this file.
>+
>+------------------------------------------------------------------------
>+Properties requiring vendor prefixes:
>+None
>+Property values requiring vendor prefixes:
>+None
>+------------------------------------------------------------------------
>+List of files:
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/create-helper.html
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/create-helper.js
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/fetch-tests.js
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/revoke-helper.html
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/resources/revoke-helper.js
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags-revoke.window.js b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags-revoke.window.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..f624f188fa82473d8ac5858eb46d850a9c9f4831
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags-revoke.window.js
>@@ -0,0 +1,99 @@
>+async_test(t => {
>+  const run_result = 'test_frame_OK';
>+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
>+    '<script>window.test_result = "' + run_result + '";</script>';
>+  const blob = new Blob([blob_contents], {type: 'text/html'});
>+  const url = URL.createObjectURL(blob);
>+
>+  const frame = document.createElement('iframe');
>+  frame.setAttribute('src', url);
>+  frame.setAttribute('style', 'display:none;');
>+  document.body.appendChild(frame);
>+  URL.revokeObjectURL(url);
>+
>+  frame.onload = t.step_func_done(() => {
>+    assert_equals(frame.contentWindow.test_result, run_result);
>+  });
>+}, 'Fetching a blob URL immediately before revoking it works in an iframe.');
>+
>+async_test(t => {
>+  const run_result = 'test_frame_OK';
>+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
>+    '<script>window.test_result = "' + run_result + '";</script>';
>+  const blob = new Blob([blob_contents], {type: 'text/html'});
>+  const url = URL.createObjectURL(blob);
>+
>+  const frame = document.createElement('iframe');
>+  frame.setAttribute('src', '/common/blank.html');
>+  frame.setAttribute('style', 'display:none;');
>+  document.body.appendChild(frame);
>+
>+  frame.onload = t.step_func(() => {
>+    frame.contentWindow.location = url;
>+    URL.revokeObjectURL(url);
>+    frame.onload = t.step_func_done(() => {
>+      assert_equals(frame.contentWindow.test_result, run_result);
>+    });
>+  });
>+}, 'Fetching a blob URL immediately before revoking it works in an iframe navigation.');
>+
>+async_test(t => {
>+  const run_result = 'test_frame_OK';
>+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
>+    '<script>window.test_result = "' + run_result + '";</script>';
>+  const blob = new Blob([blob_contents], {type: 'text/html'});
>+  const url = URL.createObjectURL(blob);
>+  const win = window.open(url);
>+  URL.revokeObjectURL(url);
>+  add_completion_callback(() => { win.close(); });
>+
>+  win.onload = t.step_func_done(() => {
>+    assert_equals(win.test_result, run_result);
>+  });
>+}, 'Opening a blob URL in a new window immediately before revoking it works.');
>+
>+function receive_message_on_channel(t, channel_name) {
>+  const channel = new BroadcastChannel(channel_name);
>+  return new Promise(resolve => {
>+    channel.addEventListener('message', t.step_func(e => {
>+      resolve(e.data);
>+    }));
>+  });
>+}
>+
>+function window_contents_for_channel(channel_name) {
>+  return '<!doctype html>\n' +
>+    '<script>\n' +
>+    'new BroadcastChannel("' + channel_name + '").postMessage("foobar");\n' +
>+    'self.close();\n' +
>+    '</script>';
>+}
>+
>+async_test(t => {
>+  const channel_name = 'noopener-window-test';
>+  const blob = new Blob([window_contents_for_channel(channel_name)], {type: 'text/html'});
>+  receive_message_on_channel(t, channel_name).then(t.step_func_done(t => {
>+    assert_equals(t, 'foobar');
>+  }));
>+  const url = URL.createObjectURL(blob);
>+  const win = window.open();
>+  win.opener = null;
>+  win.location = url;
>+  URL.revokeObjectURL(url);
>+}, 'Opening a blob URL in a noopener about:blank window immediately before revoking it works.');
>+
>+async_test(t => {
>+  const run_result = 'test_script_OK';
>+  const blob_contents = 'window.script_test_result = "' + run_result + '";';
>+  const blob = new Blob([blob_contents]);
>+  const url = URL.createObjectURL(blob);
>+
>+  const e = document.createElement('script');
>+  e.setAttribute('src', url);
>+  e.onload = t.step_func_done(() => {
>+    assert_equals(window.script_test_result, run_result);
>+  });
>+
>+  document.body.appendChild(e);
>+  URL.revokeObjectURL(url);
>+}, 'Fetching a blob URL immediately before revoking it works in <script> tags.');
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags.window.js b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags.window.js
>index 364d33bb89d5e6bc4325e4097fdab1c52e19f7a4..f20b3599013bf5b4f305549f6dc85e5756a00908 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags.window.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags.window.js
>@@ -31,7 +31,6 @@ async_test(t => {
> }, 'Blob URLs can be used in iframes, and are treated same origin');
> 
> async_test(t => {
>-  const scroll_position = 5000;
>   const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
>     '<style>body { margin: 0; } .block { height: 5000px; }</style>\n' +
>     '<body>\n' +
>@@ -43,8 +42,7 @@ async_test(t => {
>   const frame = document.createElement('iframe');
>   frame.setAttribute('src', url + '#block2');
>   document.body.appendChild(frame);
>-
>-  frame.onload = t.step_func_done(() => {
>+  frame.contentWindow.onscroll = t.step_func_done(() => {
>     assert_equals(frame.contentWindow.scrollY, 5000);
>   });
> }, 'Blob URL fragment is implemented.');
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-reload.window.js b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-reload.window.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d333b3a74aa82c58fafc5b3e5b0fab40730d13f1
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-reload.window.js
>@@ -0,0 +1,36 @@
>+function blob_url_reload_test(t, revoke_before_reload) {
>+  const run_result = 'test_frame_OK';
>+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
>+    '<script>window.test_result = "' + run_result + '";</script>';
>+  const blob = new Blob([blob_contents], {type: 'text/html'});
>+  const url = URL.createObjectURL(blob);
>+
>+  const frame = document.createElement('iframe');
>+  frame.setAttribute('src', url);
>+  frame.setAttribute('style', 'display:none;');
>+  document.body.appendChild(frame);
>+
>+  frame.onload = t.step_func(() => {
>+    if (revoke_before_reload)
>+      URL.revokeObjectURL(url);
>+    assert_equals(frame.contentWindow.test_result, run_result);
>+    frame.contentWindow.test_result = null;
>+    frame.onload = t.step_func_done(() => {
>+      assert_equals(frame.contentWindow.test_result, run_result);
>+    });
>+    // Slight delay before reloading to ensure revoke actually has had a chance
>+    // to be processed.
>+    t.step_timeout(() => {
>+      frame.contentWindow.location.reload();
>+    }, 250);
>+  });
>+}
>+
>+async_test(t => {
>+  blob_url_reload_test(t, false);
>+}, 'Reloading a blob URL succeeds.');
>+
>+
>+async_test(t => {
>+  blob_url_reload_test(t, true);
>+}, 'Reloading a blob URL succeeds even if the URL was revoked.');
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/w3c-import.log
>index dee6448b84911c545f47e50f56bdc45b4b233c66..fbf21df501109d6fe449812df714d50708ca9db4 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/w3c-import.log
>@@ -22,6 +22,7 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags-revoke.window.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-in-tags.window.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-lifetime.html
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-reload.window.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-with-fetch.any.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url-with-xhr.any.js
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/url/url_xmlhttprequest_img-expected.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/w3c-import.log
>index 5c92457d6c2c9e4e7dfeffa26774002a91245e0e..56bff5ee2af081626eab09546d8862f269755dd5 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/FileAPI/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/FileAPI/w3c-import.log
>@@ -20,3 +20,4 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/historical.https.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/idlharness.html
> /LayoutTests/imported/w3c/web-platform-tests/FileAPI/idlharness.worker.js
>+/LayoutTests/imported/w3c/web-platform-tests/FileAPI/unicode.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..9d20c69a33a54eb0f1bb1679e188ef7ee013bf57
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 41: SyntaxError: No identifiers allowed directly after numeric literal
>+
>+FAIL IndexedDB: BigInt keys and values SyntaxError: No identifiers allowed directly after numeric literal
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value.htm b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value.htm
>new file mode 100644
>index 0000000000000000000000000000000000000000..589eeabe6c6e6798406759e2d40fd28be2645473
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value.htm
>@@ -0,0 +1,72 @@
>+<!DOCTYPE html>
>+<meta charset="utf-8">
>+<title>IndexedDB: BigInt keys and values</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="support.js"></script>
>+
>+<script>
>+// BigInt and BigInt objects are supported in serialization, per
>+// https://github.com/whatwg/html/pull/3480
>+// This support allows them to be used as IndexedDB values.
>+
>+function value_test(value, predicate, name) {
>+    async_test(t => {
>+        t.step(function() {
>+            assert_true(predicate(value),
>+                        "Predicate should return true for the initial value.");
>+        });
>+
>+        createdb(t).onupgradeneeded = t.step_func(e => {
>+            e.target.result
>+                    .createObjectStore("store")
>+                    .add(value, 1);
>+
>+            e.target.onsuccess = t.step_func(e => {
>+                e.target.result
>+                        .transaction("store")
>+                        .objectStore("store")
>+                        .get(1)
>+                        .onsuccess = t.step_func(e =>
>+                {
>+                    assert_true(predicate(e.target.result),
>+                                "Predicate should return true for the deserialized result.");
>+                    t.done();
>+                });
>+            });
>+        });
>+    }, "BigInts as values in IndexedDB - " + name);
>+}
>+
>+value_test(1n,
>+           x => x === 1n,
>+           "primitive BigInt");
>+value_test(Object(1n),
>+           x => typeof x === 'object' &&
>+                x instanceof BigInt &&
>+                x.valueOf() === 1n,
>+           "BigInt object");
>+value_test({val: 1n},
>+           x => x.val === 1n,
>+           "primitive BigInt inside object");
>+value_test({val: Object(1n)},
>+           x => x.val.valueOf() === 1n &&
>+                x.val instanceof BigInt &&
>+                x.val.valueOf() === 1n,
>+           "BigInt object inside object");
>+
>+// However, BigInt is not supported as an IndexedDB key; support
>+// has been proposed in the following PR, but that change has not
>+// landed at the time this patch was written
>+// https://github.com/w3c/IndexedDB/pull/231
>+
>+function invalidKey(key, name) {
>+    test(t => {
>+        assert_throws("DataError", () => indexedDB.cmp(0, key));
>+    }, "BigInts as keys in IndexedDB - " + name);
>+}
>+
>+invalidKey(1n, "primitive BigInt");
>+// Still an error even if the IndexedDB patch lands
>+invalidKey(Object(1n), "BigInt object");
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical-expected.txt
>index 43d081ed8c948c938bbf886c9a4b20352ecefe90..0a3435defc70d9f83c679d25ae372350792b4271 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical-expected.txt
>@@ -11,4 +11,7 @@ PASS "PREV_NO_DUPLICATE" should not be supported on IDBCursor.
> PASS "READ_ONLY" should not be supported on IDBTransaction. 
> PASS "READ_WRITE" should not be supported on IDBTransaction. 
> PASS "VERSION_CHANGE" should not be supported on IDBTransaction. 
>+PASS "IDBFileHandle" should not be supported 
>+PASS "IDBFileRequest" should not be supported 
>+PASS "IDBMutableFile" should not be supported 
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical.html b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical.html
>index 73d78c816763f2d8ca5ce6c4bc0578963a497537..8e7097eb46fd2e2c1c339e44ef1805b2f8b0fcf7 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/historical.html
>@@ -63,4 +63,18 @@ test(function() {
>   // Replaced circa May 2012 by a DOMString (later, IDBTransactionMode enum).
>   assert_false('VERSION_CHANGE' in IDBTransaction);
> }, '"VERSION_CHANGE" should not be supported on IDBTransaction.');
>+
>+// Gecko-proprietary interfaces.
>+var removedFromWindow = [
>+  'IDBFileHandle',
>+  'IDBFileRequest',
>+  'IDBMutableFile',
>+];
>+
>+removedFromWindow.forEach(function(name) {
>+  test(function() {
>+    assert_false(name in window);
>+  }, '"' + name + '" should not be supported');
>+});
>+
> </script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..7e8379d16df0e00677ab9e1d4d4778bf863ec872
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update-expected.txt
>@@ -0,0 +1,8 @@
>+CONSOLE MESSAGE: line 2659: Error: assert_equals: Cursor should iterate over 4 records expected 4 but got 2
>+CONSOLE MESSAGE: line 2659: Error: assert_equals: Cursor should iterate over 4 records expected 4 but got 2
>+
>+Harness Error (FAIL), message = Error: assert_equals: Cursor should iterate over 4 records expected 4 but got 2
>+
>+TIMEOUT Calling cursor => cursor.update({}) doesn't affect index iteration Test timed out
>+TIMEOUT Calling cursor => cursor.delete() doesn't affect index iteration Test timed out
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update.htm b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update.htm
>new file mode 100644
>index 0000000000000000000000000000000000000000..d2a7b9f01e61afed41f11956482cfc631cd5421a
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update.htm
>@@ -0,0 +1,58 @@
>+<!doctype html>
>+<meta charset=utf-8>
>+<title>IndexedDB: Index iteration with cursor updates/deletes</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="support.js"></script>
>+<script>
>+const objStoreValues = [
>+  {name: 'foo', id: 1},
>+  {name: 'bar', id: 2},
>+  {name: 'foo', id: 3},
>+  {name: 'bar', id: 4},
>+];
>+
>+const objStoreValuesByIndex = [
>+  objStoreValues[1],
>+  objStoreValues[3],
>+  objStoreValues[0],
>+  objStoreValues[2],
>+];
>+
>+const functionsThatShouldNotAffectIteration = [
>+  cursor => cursor.update({}),
>+  cursor => cursor.delete(),
>+];
>+
>+functionsThatShouldNotAffectIteration.forEach((func) => indexeddb_test(
>+  (t, db) => {
>+    const objStore = db.createObjectStore('items', {autoIncrement: true});
>+    objStore.createIndex('name', 'name', {unique: false});
>+    objStoreValues.forEach((value) => objStore.add(value));
>+  },
>+  (t, db) => {
>+    const txn = db.transaction('items', 'readwrite');
>+    const objStore = txn.objectStore('items');
>+    const nameIndex = objStore.index('name');
>+
>+    const cursorValues = [];
>+    nameIndex.openCursor().onsuccess = (evt) => {
>+      const cursor = evt.target.result;
>+      if (cursor) {
>+        func(cursor);
>+        cursorValues.push(cursor.value);
>+        cursor.continue();
>+      } else {
>+        assert_equals(cursorValues.length, 4,
>+            `Cursor should iterate over 4 records`);
>+
>+        cursorValues.forEach((value, i) => {
>+          assert_object_equals(value, objStoreValuesByIndex[i]);
>+        });
>+        t.done();
>+      }
>+    }
>+  },
>+  `Calling ${func} doesn't affect index iteration`
>+));
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-common.js b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-common.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..a76ec528c99c72767a7889df1d7d7df582485ce2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-common.js
>@@ -0,0 +1,188 @@
>+// Infrastructure shared by interleaved-cursors-{small,large}.html
>+
>+// Number of objects that each iterator goes over.
>+const itemCount = 10;
>+
>+// Ratio of small objects to large objects.
>+const largeObjectRatio = 5;
>+
>+// Size of large objects. This should exceed the size of a block in the storage
>+// method underlying the browser's IndexedDB implementation. For example, this
>+// needs to exceed the LevelDB block size on Chrome, and the SQLite block size
>+// on Firefox.
>+const largeObjectSize = 48 * 1024;
>+
>+function objectKey(cursorIndex, itemIndex) {
>+  return `${cursorIndex}-key-${itemIndex}`;
>+}
>+
>+function objectValue(cursorIndex, itemIndex) {
>+  if ((cursorIndex * itemCount + itemIndex) % largeObjectRatio === 0) {
>+    // We use a typed array (as opposed to a string) because IndexedDB
>+    // implementations may serialize strings using UTF-8 or UTF-16, yielding
>+    // larger IndexedDB entries than we'd expect. It's very unlikely that an
>+    // IndexedDB implementation would use anything other than the raw buffer to
>+    // serialize a typed array.
>+    const buffer = new Uint8Array(largeObjectSize);
>+
>+    // Some IndexedDB implementations, like LevelDB, compress their data blocks
>+    // before storing them to disk. We use a simple 32-bit xorshift PRNG, which
>+    // should be sufficient to foil any fast generic-purpose compression scheme.
>+
>+    // 32-bit xorshift - the seed can't be zero
>+    let state = 1000 + (cursorIndex * itemCount + itemIndex);
>+
>+    for (let i = 0; i < largeObjectSize; ++i) {
>+      state ^= state << 13;
>+      state ^= state >> 17;
>+      state ^= state << 5;
>+      buffer[i] = state & 0xff;
>+    }
>+
>+    return buffer;
>+  }
>+  return [cursorIndex, 'small', itemIndex];
>+}
>+
>+// Writes the objects to be read by one cursor. Returns a promise that resolves
>+// when the write completes.
>+//
>+// We want to avoid creating a large transaction, because that is outside the
>+// test's scope, and it's a bad practice. So we break up the writes across
>+// multiple transactions. For simplicity, each transaction writes all the
>+// objects that will be read by a cursor.
>+function writeCursorObjects(database, cursorIndex) {
>+  return new Promise((resolve, reject) => {
>+    const transaction = database.transaction('cache', 'readwrite');
>+    transaction.onabort = () => { reject(transaction.error); };
>+
>+    const store = transaction.objectStore('cache');
>+    for (let i = 0; i < itemCount; ++i) {
>+      store.put({
>+          key: objectKey(cursorIndex, i), value: objectValue(cursorIndex, i)});
>+    }
>+    transaction.oncomplete = resolve;
>+  });
>+}
>+
>+// Returns a promise that resolves when the store has been populated.
>+function populateTestStore(testCase, database, cursorCount) {
>+  let promiseChain = Promise.resolve();
>+
>+  for (let i = 0; i < cursorCount; ++i)
>+    promiseChain = promiseChain.then(() => writeCursorObjects(database, i));
>+
>+  return promiseChain;
>+}
>+
>+// Reads cursors in an interleaved fashion, as shown below.
>+//
>+// Given N cursors, each of which points to the beginning of a K-item sequence,
>+// the following accesses will be made.
>+//
>+// OC(i)    = open cursor i
>+// RD(i, j) = read result of cursor i, which should be at item j
>+// CC(i)    = continue cursor i
>+// |        = wait for onsuccess on the previous OC or CC
>+//
>+// OC(1)            | RD(1, 1) OC(2) | RD(2, 1) OC(3) | ... | RD(n-1, 1) CC(n) |
>+// RD(n, 1)   CC(1) | RD(1, 2) CC(2) | RD(2, 2) CC(3) | ... | RD(n-1, 2) CC(n) |
>+// RD(n, 2)   CC(1) | RD(1, 3) CC(2) | RD(2, 3) CC(3) | ... | RD(n-1, 3) CC(n) |
>+// ...
>+// RD(n, k-1) CC(1) | RD(1, k) CC(2) | RD(2, k) CC(3) | ... | RD(n-1, k) CC(n) |
>+// RD(n, k)           done
>+function interleaveCursors(testCase, store, cursorCount) {
>+  return new Promise((resolve, reject) => {
>+    // The cursors used for iteration are stored here so each cursor's onsuccess
>+    // handler can call continue() on the next cursor.
>+    const cursors = [];
>+
>+    // The results of IDBObjectStore.openCursor() calls are stored here so we
>+    // we can change the requests' onsuccess handler after every
>+    // IDBCursor.continue() call.
>+    const requests = [];
>+
>+    const checkCursorState = (cursorIndex, itemIndex) => {
>+      const cursor = cursors[cursorIndex];
>+      assert_equals(cursor.key, objectKey(cursorIndex, itemIndex));
>+      assert_equals(cursor.value.key, objectKey(cursorIndex, itemIndex));
>+      assert_equals(
>+          cursor.value.value.join('-'),
>+          objectValue(cursorIndex, itemIndex).join('-'));
>+    };
>+
>+    const openCursor = (cursorIndex, callback) => {
>+      const request = store.openCursor(
>+          IDBKeyRange.lowerBound(objectKey(cursorIndex, 0)));
>+      requests[cursorIndex] = request;
>+
>+      request.onsuccess = testCase.step_func(() => {
>+        const cursor = request.result;
>+        cursors[cursorIndex] = cursor;
>+        checkCursorState(cursorIndex, 0);
>+        callback();
>+      });
>+      request.onerror = event => reject(request.error);
>+    };
>+
>+    const readItemFromCursor = (cursorIndex, itemIndex, callback) => {
>+      const request = requests[cursorIndex];
>+      request.onsuccess = testCase.step_func(() => {
>+        const cursor = request.result;
>+        cursors[cursorIndex] = cursor;
>+        checkCursorState(cursorIndex, itemIndex);
>+        callback();
>+      });
>+
>+      const cursor = cursors[cursorIndex];
>+      cursor.continue();
>+    };
>+
>+    // We open all the cursors one at a time, then cycle through the cursors and
>+    // call continue() on each of them. This access pattern causes maximal
>+    // trashing to an LRU cursor cache. Eviction scheme aside, any cache will
>+    // have to evict some cursors, and this access pattern verifies that the
>+    // cache correctly restores the state of evicted cursors.
>+    const steps = [];
>+    for (let cursorIndex = 0; cursorIndex < cursorCount; ++cursorIndex)
>+      steps.push(openCursor.bind(null, cursorIndex));
>+    for (let itemIndex = 1; itemIndex < itemCount; ++itemIndex) {
>+      for (let cursorIndex = 0; cursorIndex < cursorCount; ++cursorIndex)
>+        steps.push(readItemFromCursor.bind(null, cursorIndex, itemIndex));
>+    }
>+
>+    const runStep = (stepIndex) => {
>+      if (stepIndex === steps.length) {
>+        resolve();
>+        return;
>+      }
>+      steps[stepIndex](() => { runStep(stepIndex + 1); });
>+    };
>+    runStep(0);
>+  });
>+}
>+
>+function cursorTest(cursorCount) {
>+  promise_test(testCase => {
>+    return createDatabase(testCase, (database, transaction) => {
>+      const store = database.createObjectStore('cache',
>+          { keyPath: 'key', autoIncrement: true });
>+    }).then(database => {
>+      return populateTestStore(testCase, database, cursorCount).then(
>+          () => database);
>+    }).then(database => {
>+      database.close();
>+    }).then(() => {
>+      return openDatabase(testCase);
>+    }).then(database => {
>+      const transaction = database.transaction('cache', 'readonly');
>+      transaction.onabort = () => { reject(transaction.error); };
>+
>+      const store = transaction.objectStore('cache');
>+      return interleaveCursors(testCase, store, cursorCount).then(
>+          () => database);
>+    }).then(database => {
>+      database.close();
>+    });
>+  }, `${cursorCount} cursors`);
>+}
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..60e441b91d938071f75b2fc9b712803cb936e919
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS 250 cursors 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large.html b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..6f4e440e1dac8c6389d0882b314a10ea84ad9af8
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large.html
>@@ -0,0 +1,12 @@
>+<!doctype html>
>+<meta charset="utf-8">
>+<meta name="timeout" content="long">
>+<title>IndexedDB: Interleaved iteration of multiple cursors</title>
>+<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="support-promises.js"></script>
>+<script src="interleaved-cursors-common.js"></script>
>+<script>
>+cursorTest(250);
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..67798bd5c9b97fede4abaf453c069f1dd0893c47
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt
>@@ -0,0 +1,5 @@
>+
>+PASS 1 cursors 
>+PASS 10 cursors 
>+PASS 100 cursors 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small.html b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a4c47771782f61c8ef17398e66d57e8d03db5830
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small.html
>@@ -0,0 +1,14 @@
>+<!doctype html>
>+<meta charset="utf-8">
>+<meta name="timeout" content="long">
>+<title>IndexedDB: Interleaved iteration of multiple cursors</title>
>+<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="support-promises.js"></script>
>+<script src="interleaved-cursors-common.js"></script>
>+<script>
>+cursorTest(1);
>+cursorTest(10);
>+cursorTest(100);
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt
>index be90589cf5c90b96658d6ec845a04ea42c10b449..40cc840a1cf7fa5c57d683dd37089517c2ba7cf6 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt
>@@ -5,5 +5,4 @@ PASS Type: Blob, identifier: size
> PASS Type: Blob, identifier: type 
> PASS Type: File, identifier: name 
> PASS Type: File, identifier: lastModified 
>-FAIL Type: File, identifier: lastModifiedDate Provided data is inadequate.
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers.htm b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers.htm
>index 331169b5c9033d466b93b4a6f6517822ac213bd8..cb64d0b708eb3f97d99b0b754fcdf9bd12394821 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers.htm
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers.htm
>@@ -38,11 +38,6 @@
>     property: 'lastModified',
>     instance: new File([''], '', {lastModified: 123}),
>   },
>-  {
>-    type: 'File',
>-    property: 'lastModifiedDate',
>-    instance: new File([''], '', {lastModified: 123}),
>-  },
> ].forEach(function(testcase) {
>   indexeddb_test(
>     (t, db) => {
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath.htm b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath.htm
>index b59d614e8a9b47f300c4924e96284a38ed9b4f20..4985712a215c28b6a798e789a7a384a4719760b5 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath.htm
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath.htm
>@@ -125,7 +125,7 @@
>             "[Blob.length, Blob.type]");
>     }
> 
>-    // File.name and File.lastModifiedDate is not testable automatically
>+    // File.name and File.lastModified is not testable automatically
> 
>     keypath(['name', 'type'],
>         [ { name: "orange", type: "fruit" }, { name: "orange", type: ["telecom", "french"] } ],
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/support.js b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/support.js
>index ac9c2f3241941a892e46cfdeb1463a7c05c8ebd5..5edbdacbcc7d0cf27d0e3330198b55d50540345e 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/support.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/support.js
>@@ -12,7 +12,7 @@ add_completion_callback(function(tests)
>         if(tests[i].db)
>         {
>             tests[i].db.close();
>-            window.indexedDB.deleteDatabase(tests[i].db.name);
>+            self.indexedDB.deleteDatabase(tests[i].db.name);
>         }
>     }
> });
>@@ -43,9 +43,9 @@ function createdb_for_multiple_tests(dbname, version) {
>         dbname = (dbname ? dbname : "testdb-" + new Date().getTime() + Math.random() );
> 
>     if (version)
>-        rq_open = window.indexedDB.open(dbname, version);
>+        rq_open = self.indexedDB.open(dbname, version);
>     else
>-        rq_open = window.indexedDB.open(dbname);
>+        rq_open = self.indexedDB.open(dbname);
> 
>     function auto_fail(evt, current_test) {
>         /* Fail handlers, if we haven't set on/whatever/, don't
>@@ -107,7 +107,7 @@ function assert_key_equals(actual, expected, description) {
> function indexeddb_test(upgrade_func, open_func, description, options) {
>   async_test(function(t) {
>     options = Object.assign({upgrade_will_abort: false}, options);
>-    var dbname = document.location + '-' + t.name;
>+    var dbname = location + '-' + t.name;
>     var del = indexedDB.deleteDatabase(dbname);
>     del.onerror = t.unreached_func('deleteDatabase should succeed');
>     var open = indexedDB.open(dbname, 1);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/w3c-import.log
>index 836fd054392034e415707d2742e91d8e279585a2..836ba1d14939730138d3768c284a3a7470213148 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/w3c-import.log
>@@ -17,6 +17,7 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/OWNERS
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/README.md
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/abort-in-initial-upgradeneeded.html
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bigint_value.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/bindings-inject-key.html
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/clone-before-keypath-eval.html
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/close-in-upgradeneeded.html
>@@ -48,6 +49,7 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-direction-objectstore-keyrange.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-direction-objectstore.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-direction.htm
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-iterating-update.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-key.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-primarykey.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbcursor-request-source.html
>@@ -316,6 +318,9 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/idbworker.js
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/index_sort_order.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interfaces.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-common.js
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large.html
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small.html
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/key-conversion-exceptions.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/key_invalid.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/key_valid.html
>@@ -364,4 +369,5 @@ List of files:
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/upgrade-transaction-lifecycle-user-aborted.html
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/value.htm
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/value_recursive.htm
>+/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value.html
> /LayoutTests/imported/w3c/web-platform-tests/IndexedDB/writer-starvation.htm
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3558542d3c787cdd7ad47e1851b43bf522f6476e
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value-expected.txt
>@@ -0,0 +1,5 @@
>+
>+FAIL WebAssembly module as an IndexedDB value Failed to store record in an IDBObjectStore: An object could not be cloned.
>+FAIL WebAssembly module in a JavaScript object IndexedDB value Failed to store record in an IDBObjectStore: An object could not be cloned.
>+FAIL WebAssembly module in an IndexedDB value with an inline key Failed to store record in an IDBObjectStore: An object could not be cloned.
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value.html b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..9fcfd780b8e59ff49e54406fbc4106e683c76025
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/IndexedDB/wasm-module-value.html
>@@ -0,0 +1,109 @@
>+<!doctype html>
>+<meta charset="utf8">
>+<meta name="timeout" content="long">
>+<title>IndexedDB: WebAssembly module values</title>
>+<link rel="help" href="https://w3c.github.io/IndexedDB/">
>+<link rel="help" href="https://webassembly.github.io/spec/">
>+<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script src="support-promises.js"></script>
>+<script>
>+'use strict';
>+
>+// Binary representation for a WASM module that exports an "inc" function.
>+//
>+// This test covers storing WASM modules in IndexedDB. Its failure should only
>+// be debugged if WASM specification tests pass. To this end, the test does not
>+// use the WASM module builder helpers, trading off WASM debuggability in return
>+// for having the WASM wire bytes listed explicitly in the test body. Having the
>+// wire bytes spelled out can be helpful when debugging IndexedDB failures.
>+let wasm_module_bytes = new Uint8Array([
>+  0x00, 0x61, 0x73, 0x6d,  // Magic.
>+  0x01, 0x00, 0x00, 0x00,  // Version.
>+  0x01, 0x06, 0x01,              // Type section - 6 bytes, 1 entry
>+  0x60, 0x01, 0x7f, 0x01, 0x7f,  // Type 0. Function: (i32) -> (i32)
>+  0x03, 0x02, 0x01,   // Function section - 2 bytes, 1 entry
>+  0x00,               // Function 0: Type 0
>+  0x07, 0x07, 0x01,              // Export section - 7 bytes, 1 entry
>+  0x03, 0x69, 0x6e, 0x63,        // Export 1. { name: "inc"
>+  0x00, 0x00,                    //             desc: function 0 }
>+  0x0a, 0x09, 0x01,  // Code section: 9 bytes, 1 entry
>+  0x07, 0x00,        // Function 1: 7 code bytes, 0 locals
>+  0x20, 0x00,        //   getlocal 0
>+  0x41, 0x01,        //   i32.const 1
>+  0x6a,              //   i32.add
>+  0x0b,              //   end
>+]);
>+
>+promise_test(async testCase => {
>+  const wasm_module = await WebAssembly.compile(wasm_module_bytes.buffer);
>+
>+  const database = await createDatabase(testCase, (database, transaction) => {
>+    const store = database.createObjectStore('store');
>+    store.put(wasm_module, 'key1');
>+  });
>+
>+  const result = await new Promise((resolve, reject) => {
>+    const transaction = database.transaction(['store'], 'readonly');
>+    const store = transaction.objectStore('store');
>+    const request = store.get('key1');
>+    request.onsuccess = (event) => resolve(event.target.result);
>+    request.onerror = (event) => reject(event.target.error);
>+  });
>+
>+  database.close();
>+
>+  const instance = await WebAssembly.instantiate(result);
>+  assert_equals(
>+      instance.exports['inc'](42), 43, 'inc should increment its argument');
>+}, 'WebAssembly module as an IndexedDB value');
>+
>+promise_test(async testCase => {
>+  const wasm_module = await WebAssembly.compile(wasm_module_bytes.buffer);
>+
>+  const database = await createDatabase(testCase, (database, transaction) => {
>+    const store = database.createObjectStore('store');
>+    store.put({ module: wasm_module }, 'key1');
>+  });
>+
>+  const result = await new Promise((resolve, reject) => {
>+    const transaction = database.transaction(['store'], 'readonly');
>+    const store = transaction.objectStore('store');
>+    const request = store.get('key1');
>+    request.onsuccess = (event) => resolve(event.target.result);
>+    request.onerror = (event) => reject(event.target.error);
>+  });
>+
>+  database.close();
>+
>+  const instance = await WebAssembly.instantiate(result.module);
>+  assert_equals(
>+      instance.exports['inc'](42), 43, 'inc should increment its argument');
>+}, 'WebAssembly module in a JavaScript object IndexedDB value');
>+
>+promise_test(async testCase => {
>+  const wasm_module = await WebAssembly.compile(wasm_module_bytes.buffer);
>+
>+  const database = await createDatabase(testCase, (database, transaction) => {
>+    const store = database.createObjectStore('store', { keyPath: 'key' });
>+    store.put({ key: 'key1', module: wasm_module });
>+  });
>+
>+  const result = await new Promise((resolve, reject) => {
>+    const transaction = database.transaction(['store'], 'readonly');
>+    const store = transaction.objectStore('store');
>+    const request = store.get('key1');
>+    request.onsuccess = (event) => resolve(event.target.result);
>+    request.onerror = (event) => reject(event.target.error);
>+  });
>+
>+  database.close();
>+
>+  assert_equals('key1', result.key);
>+  const instance = await WebAssembly.instantiate(result.module);
>+  assert_equals(
>+      instance.exports['inc'](42), 43, 'inc should increment its argument');
>+}, 'WebAssembly module in an IndexedDB value with an inline key');
>+
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..6ba2c901e27d4f0a39139ef702b94ad21d9a623b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CBC}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CBC}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CBC}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..19c9fb28b3bc073a9e18e8abed0838f29bd0ce69
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["AES-CBC"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..6ba2c901e27d4f0a39139ef702b94ad21d9a623b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CBC}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CBC}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CBC}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CBC}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt
>index 6ba2c901e27d4f0a39139ef702b94ad21d9a623b..68ce262a8fdbe41eff8152cb4f38f6db1a31cb93 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker-expected.txt
>@@ -1,740 +1,17 @@
>-
>-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({length: 128, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, true, []) 
>-
>+layer at (0,0) size 800x600
>+  RenderView at (0,0) size 800x600
>+layer at (0,0) size 800x600
>+  RenderBlock {HTML} at (0,0) size 800x600
>+    RenderBody {BODY} at (8,8) size 784x579
>+      RenderBlock {PRE} at (0,0) size 784x150
>+        RenderText {#text} at (0,0) size 765x150
>+          text run at (0,0) width 508: "{\"error\": {\"message\": \"Traceback (most recent call last):\\n  File"
>+          text run at (0,15) width 500: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,30) width 742: "tests/tools/wptserve/wptserve/handlers.py\\\", line 254, in __call__\\n    rv = self.func(request,"
>+          text run at (0,45) width 640: "response)\\n  File \\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,60) width 531: "tests/tools/serve/serve.py\\\", line 58, in handle_request\\n    meta ="
>+          text run at (0,75) width 352: "\\\"\\\\n\\\".join(self._get_meta(request))\\n  File"
>+          text run at (0,90) width 765: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-tests/tools/serve/serve.py\\\", line"
>+          text run at (0,105) width 765: "93, in _get_meta\\n    with open(path, \\\"rb\\\") as f:\\nIOError: [Errno 2] No such file or directory:"
>+          text run at (0,120) width 492: "'/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,135) width 640: "tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js'\\n\", \"code\": 500}}"
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js
>deleted file mode 100644
>index 7bb3e7f697fd80e9333337ecdbe6285f7776d353..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["AES-CBC"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..9b38fb3329c5a71c0f4aef6f90ce9d0aa142ff03
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CTR}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CTR}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CTR}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..2f8a0b3596f192dd9382a4229634fbd357b7a6ec
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["AES-CTR"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..9b38fb3329c5a71c0f4aef6f90ce9d0aa142ff03
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-CTR}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-CTR}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CTR}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-CTR}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt
>index 9b38fb3329c5a71c0f4aef6f90ce9d0aa142ff03..25782059c61fd9e4329bf36d5933d431867623f0 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker-expected.txt
>@@ -1,740 +1,17 @@
>-
>-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({length: 128, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, true, []) 
>-
>+layer at (0,0) size 800x600
>+  RenderView at (0,0) size 800x600
>+layer at (0,0) size 800x600
>+  RenderBlock {HTML} at (0,0) size 800x600
>+    RenderBody {BODY} at (8,8) size 784x579
>+      RenderBlock {PRE} at (0,0) size 784x150
>+        RenderText {#text} at (0,0) size 765x150
>+          text run at (0,0) width 508: "{\"error\": {\"message\": \"Traceback (most recent call last):\\n  File"
>+          text run at (0,15) width 500: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,30) width 742: "tests/tools/wptserve/wptserve/handlers.py\\\", line 254, in __call__\\n    rv = self.func(request,"
>+          text run at (0,45) width 640: "response)\\n  File \\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,60) width 531: "tests/tools/serve/serve.py\\\", line 58, in handle_request\\n    meta ="
>+          text run at (0,75) width 352: "\\\"\\\\n\\\".join(self._get_meta(request))\\n  File"
>+          text run at (0,90) width 765: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-tests/tools/serve/serve.py\\\", line"
>+          text run at (0,105) width 765: "93, in _get_meta\\n    with open(path, \\\"rb\\\") as f:\\nIOError: [Errno 2] No such file or directory:"
>+          text run at (0,120) width 492: "'/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,135) width 640: "tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js'\\n\", \"code\": 500}}"
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js
>deleted file mode 100644
>index f6766b27bba3d790d049a0e583362212febdc4af..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["AES-CTR"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f23c217e60dff1c76b83bc260c0673f970339474
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-GCM}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-GCM}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-GCM}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..bb0ab46fbe6c99547446463df71132425266a3e1
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["AES-GCM"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f23c217e60dff1c76b83bc260c0673f970339474
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker-expected.txt
>@@ -0,0 +1,740 @@
>+
>+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({length: 128, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-GCM}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-GCM}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-GCM}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-GCM}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt
>index f23c217e60dff1c76b83bc260c0673f970339474..8e53c9f606b9e39c60badbbd18d9e1e0aaa4b25c 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker-expected.txt
>@@ -1,740 +1,17 @@
>-
>-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({length: 128, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, true, []) 
>-
>+layer at (0,0) size 800x600
>+  RenderView at (0,0) size 800x600
>+layer at (0,0) size 800x600
>+  RenderBlock {HTML} at (0,0) size 800x600
>+    RenderBody {BODY} at (8,8) size 784x579
>+      RenderBlock {PRE} at (0,0) size 784x150
>+        RenderText {#text} at (0,0) size 765x150
>+          text run at (0,0) width 508: "{\"error\": {\"message\": \"Traceback (most recent call last):\\n  File"
>+          text run at (0,15) width 500: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,30) width 742: "tests/tools/wptserve/wptserve/handlers.py\\\", line 254, in __call__\\n    rv = self.func(request,"
>+          text run at (0,45) width 640: "response)\\n  File \\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,60) width 531: "tests/tools/serve/serve.py\\\", line 58, in handle_request\\n    meta ="
>+          text run at (0,75) width 352: "\\\"\\\\n\\\".join(self._get_meta(request))\\n  File"
>+          text run at (0,90) width 765: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-tests/tools/serve/serve.py\\\", line"
>+          text run at (0,105) width 765: "93, in _get_meta\\n    with open(path, \\\"rb\\\") as f:\\nIOError: [Errno 2] No such file or directory:"
>+          text run at (0,120) width 492: "'/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,135) width 640: "tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js'\\n\", \"code\": 500}}"
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js
>deleted file mode 100644
>index 1383e5895595cf9972d1a169edcabbf580136e1b..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["AES-GCM"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..180a9bcd490e499fc5145fa5059f543f91c42903
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any-expected.txt
>@@ -0,0 +1,482 @@
>+
>+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({length: 128, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-KW}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-KW}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-KW}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..54d685f7565735f698a0d2886e7c5a3c255ea913
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["AES-KW"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..180a9bcd490e499fc5145fa5059f543f91c42903
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker-expected.txt
>@@ -0,0 +1,482 @@
>+
>+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({length: 128, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, []) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({length: 128, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 128, name: AES-KW}, true, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 192, name: AES-KW}, true, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-KW}, false, []) 
>+PASS Empty usages: generateKey({length: 256, name: AES-KW}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt
>index 180a9bcd490e499fc5145fa5059f543f91c42903..7a00a4c7b8e1657549fe3cad451ca99f31dfbdd4 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker-expected.txt
>@@ -1,482 +1,17 @@
>-
>-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({length: 128, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, true, []) 
>-
>+layer at (0,0) size 800x600
>+  RenderView at (0,0) size 800x600
>+layer at (0,0) size 800x600
>+  RenderBlock {HTML} at (0,0) size 800x600
>+    RenderBody {BODY} at (8,8) size 784x579
>+      RenderBlock {PRE} at (0,0) size 784x150
>+        RenderText {#text} at (0,0) size 765x150
>+          text run at (0,0) width 508: "{\"error\": {\"message\": \"Traceback (most recent call last):\\n  File"
>+          text run at (0,15) width 500: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,30) width 742: "tests/tools/wptserve/wptserve/handlers.py\\\", line 254, in __call__\\n    rv = self.func(request,"
>+          text run at (0,45) width 640: "response)\\n  File \\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,60) width 531: "tests/tools/serve/serve.py\\\", line 58, in handle_request\\n    meta ="
>+          text run at (0,75) width 352: "\\\"\\\\n\\\".join(self._get_meta(request))\\n  File"
>+          text run at (0,90) width 765: "\\\"/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-tests/tools/serve/serve.py\\\", line"
>+          text run at (0,105) width 765: "93, in _get_meta\\n    with open(path, \\\"rb\\\") as f:\\nIOError: [Errno 2] No such file or directory:"
>+          text run at (0,120) width 492: "'/Users/bmac/code/webkit/LayoutTests/imported/w3c/web-platform-"
>+          text run at (0,135) width 632: "tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js'\\n\", \"code\": 500}}"
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js
>deleted file mode 100644
>index 04f5bb6edab65d9b22281cf2e0bb8310cb16e9f2..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["AES-KW"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e797642e03c42a0edf449c736ab6db07a007b1c5
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any-expected.txt
>@@ -0,0 +1,442 @@
>+
>+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({name: ECDH, namedCurve: P-256}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, false, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, true, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, false, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, true, []) 
>+FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..4c13c5ac5721f7fe1a35152308de7eb6b9e41a97
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["ECDH"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e797642e03c42a0edf449c736ab6db07a007b1c5
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker-expected.txt
>@@ -0,0 +1,442 @@
>+
>+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({name: ECDH, namedCurve: P-256}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits, deriveKey]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, false, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, true, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, false, []) 
>+PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, true, []) 
>+FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker-expected.txt
>deleted file mode 100644
>index e797642e03c42a0edf449c736ab6db07a007b1c5..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker-expected.txt
>+++ /dev/null
>@@ -1,442 +0,0 @@
>-
>-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({name: ECDH, namedCurve: P-256}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, false, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, true, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, false, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, true, []) 
>-FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.js
>deleted file mode 100644
>index a7e6a7240bcc4ab3d70d9513bcb7c9267c81307b..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["ECDH"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e2532ee71c2782488784aad5f6a2445bc21cb2fc
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any-expected.txt
>@@ -0,0 +1,420 @@
>+
>+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({name: ECDSA, namedCurve: P-256}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign, verify, sign, sign, verify]) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, false, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, true, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, false, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, true, []) 
>+FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..74cd480e2c2de0eab571174726d282e0ba9fba17
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["ECDSA"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e2532ee71c2782488784aad5f6a2445bc21cb2fc
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker-expected.txt
>@@ -0,0 +1,420 @@
>+
>+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({name: ECDSA, namedCurve: P-256}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, []) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign, verify, sign, sign, verify]) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, false, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, true, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, false, []) 
>+PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, true, []) 
>+FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker-expected.txt
>deleted file mode 100644
>index e2532ee71c2782488784aad5f6a2445bc21cb2fc..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker-expected.txt
>+++ /dev/null
>@@ -1,420 +0,0 @@
>-
>-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({name: ECDSA, namedCurve: P-256}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign, verify, sign, sign, verify]) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, true, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, true, []) 
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.js
>deleted file mode 100644
>index a1f471141de052643c42609f089876498d1c624f..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["ECDSA"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a26c48a091a352061004ab35bb58b75250b788df
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any-expected.txt
>@@ -0,0 +1,454 @@
>+
>+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, length: 160, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..708d33beba4925a9ee2c402d5a0b80eb0dc36126
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["HMAC"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a26c48a091a352061004ab35bb58b75250b788df
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker-expected.txt
>@@ -0,0 +1,454 @@
>+
>+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, length: 160, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>+PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker-expected.txt
>deleted file mode 100644
>index a26c48a091a352061004ab35bb58b75250b788df..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker-expected.txt
>+++ /dev/null
>@@ -1,454 +0,0 @@
>-
>-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, length: 160, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.js
>deleted file mode 100644
>index 9dfbbb9c065a7352c667fc7a1d671dfe922a2f91..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["HMAC"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d8342f45b1d63a2ac3f5e0278d9434ed0209be24
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any-expected.txt
>@@ -0,0 +1,498 @@
>+
>+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-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..4ec0ec20bac1cef5a61ae8ec3e735e689bda5af1
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["RSA-OAEP"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d8342f45b1d63a2ac3f5e0278d9434ed0209be24
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker-expected.txt
>@@ -0,0 +1,498 @@
>+
>+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-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, encrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker-expected.txt
>deleted file mode 100644
>index d8342f45b1d63a2ac3f5e0278d9434ed0209be24..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker-expected.txt
>+++ /dev/null
>@@ -1,498 +0,0 @@
>-
>-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-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.js
>deleted file mode 100644
>index 39de6d6efecf7d28f9113cd44ea03749f65daf11..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["RSA-OAEP"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..037f0956f5d4536ef735ff168015d219d3020a50
>--- /dev/null
>+++ b/LayoutTests/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/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..557b5785e348ee41057d61d89ea088e35aa1279b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["RSA-PSS"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..037f0956f5d4536ef735ff168015d219d3020a50
>--- /dev/null
>+++ b/LayoutTests/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, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt
>deleted file mode 100644
>index 96c93d4466644c64a4a9c572f28ae98b10d4b19d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt
>+++ /dev/null
>@@ -1,394 +0,0 @@
>-
>-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/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.js
>deleted file mode 100644
>index 8b1110d7f096b08585126a2a96f8a8bb2e5f44fd..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["RSA-PSS"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..be08f1153e8896f2f18ca12fa7bb2415dce8f135
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, 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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..45771bf0d46eadf6cb8a852ee77538f5f8891aa8
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.js
>@@ -0,0 +1,4 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=failures.js
>+run_test(["RSASSA-PKCS1-v1_5"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..be08f1153e8896f2f18ca12fa7bb2415dce8f135
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>+PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, 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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) 
>+PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>+PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker-expected.txt
>deleted file mode 100644
>index be08f1153e8896f2f18ca12fa7bb2415dce8f135..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker-expected.txt
>+++ /dev/null
>@@ -1,394 +0,0 @@
>-
>-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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, 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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.js
>deleted file mode 100644
>index 4df0b896fe37c2a18d91b72b02d920aa959be880..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.js
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("failures.js");
>-run_test(["RSASSA-PKCS1-v1_5"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes.js
>index 6a74c01ddde4fd4a10fd8144d582e77fda76713f..b99e44d66d40f882fdcd217ddba8b41cba457ea6 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes.js
>@@ -70,7 +70,6 @@ function run_test(algorithmNames, slowTest) {
>         }, testTag + ": generateKey" + parameterString(algorithm, extractable, usages));
>     }
> 
>-
>     // Test all valid sets of parameters for successful
>     // key generation.
>     testVectors.forEach(function(vector) {
>@@ -78,7 +77,7 @@ function run_test(algorithmNames, slowTest) {
>             allAlgorithmSpecifiersFor(name).forEach(function(algorithm) {
>                 allValidUsages(vector.usages, false, vector.mandatoryUsages).forEach(function(usages) {
>                     [false, true].forEach(function(extractable) {
>-                        testSuccess(algorithm, extractable, usages, vector.resultType, "Success");
>+                        subsetTest(testSuccess, algorithm, extractable, usages, vector.resultType, "Success");
>                     });
>                 });
>             });
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..6feb60e5caa79590c3685bb247ed9ccbe01910b1
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["AES-CBC"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..15014066f44818d2f645503babc9915108b99d23
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker-expected.txt
>deleted file mode 100644
>index 377dd279c6acd615a54649178cbf3c0c5f9517bd..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker-expected.txt
>+++ /dev/null
>@@ -1,290 +0,0 @@
>-
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.js
>deleted file mode 100644
>index 0710c9e7b504533b3f7a089f83e3b4c28af116bd..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["AES-CBC"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..7b4f2df5fb1b3cf923929ab349a4968db68bf35f
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["AES-CTR"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..201518abda595d4274ce8dbfe3e7246d4bafa9a5
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker-expected.txt
>deleted file mode 100644
>index e4db9f863ec0a63d817302bd9da7e5732ab8b7d3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker-expected.txt
>+++ /dev/null
>@@ -1,290 +0,0 @@
>-
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.js
>deleted file mode 100644
>index 51529f000fd8e0070014c94a9f28593185e0c785..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["AES-CTR"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..8e7bc92170c65b2377da3665ac4d564d9fa9729b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["AES-GCM"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..8e49f763f123c060dcdcdb538a37a279580c1d6b
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker-expected.txt
>deleted file mode 100644
>index 074f16aa890d925ef69466b3130917dda798efeb..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker-expected.txt
>+++ /dev/null
>@@ -1,290 +0,0 @@
>-
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.js
>deleted file mode 100644
>index 1f6a1bc96e0060efb8ec681fb0dcbb7942734162..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["AES-GCM"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..5eb023369f402971dee5870a692fd21241d19525
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["AES-KW"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5814226c9ae40717846aa1bf302939c43e0ebede
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker-expected.txt
>deleted file mode 100644
>index 43842a1c474ffaf7aae0cc08e855a5876c29b77e..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker-expected.txt
>+++ /dev/null
>@@ -1,74 +0,0 @@
>-
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.js
>deleted file mode 100644
>index 058cf83d0576200f3103cd1dd607886fd6ded8dd..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["AES-KW"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..87590d23ea4340c7adfd298d3ff828f9f839ef71
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["ECDH"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5f33657c5108be7cea8feb4112bad6ccfaad32da
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker-expected.txt
>deleted file mode 100644
>index ed7540195c4c2384b3345f9694987869e7568bc0..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker-expected.txt
>+++ /dev/null
>@@ -1,74 +0,0 @@
>-
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.js
>deleted file mode 100644
>index a21b7d04e8bcd5493c1bfc5e7eae9f6ed7ba6206..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["ECDH"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..734d86972fc6786598b186e95e291a200384f282
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["ECDSA"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..09612a0e258b00ba1ab50e913350b476fbfcb87c
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker-expected.txt
>deleted file mode 100644
>index d48e032088ed10a3a088de6f96b9ddf985e56d80..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker-expected.txt
>+++ /dev/null
>@@ -1,56 +0,0 @@
>-
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.js
>deleted file mode 100644
>index 13f7e3539ec4745a5aefdb91bcff6c3491f026ef..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["ECDSA"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..bc106f3c117c76247484b142c432f732bcafc848
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.js
>@@ -0,0 +1,5 @@
>+// META: timeout=long
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["HMAC"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e3797e3d90717c3de686155772b5faeb10a318bd
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker-expected.txt
>deleted file mode 100644
>index 76b75e6789694d6ab1e1984239fb81d116fcfdf9..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker-expected.txt
>+++ /dev/null
>@@ -1,98 +0,0 @@
>-
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [sign, verify, sign, verify]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.js
>deleted file mode 100644
>index 2b50b90905858eae62f4ced5644cfe8403d7a569..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["HMAC"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..b0412286c58ebcc5549963c99b70d793717c82b8
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.js
>@@ -0,0 +1,21 @@
>+// META: timeout=long
>+// META: variant=?1-10
>+// META: variant=?11-20
>+// META: variant=?21-30
>+// META: variant=?31-40
>+// META: variant=?41-50
>+// META: variant=?51-60
>+// META: variant=?61-70
>+// META: variant=?71-80
>+// META: variant=?81-90
>+// META: variant=?91-100
>+// META: variant=?101-110
>+// META: variant=?111-120
>+// META: variant=?121-130
>+// META: variant=?131-140
>+// META: variant=?141-150
>+// META: variant=?151-last
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["RSA-OAEP"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..49c2e9eae579f16f4040d13b6fb92674b05e62f3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker-expected.txt
>deleted file mode 100644
>index 6a7a67bc53a5310e449e1561f7cb200eecc6dced..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker-expected.txt
>+++ /dev/null
>@@ -1,159 +0,0 @@
>-
>-Harness Error (TIMEOUT), message = null
>-
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-TIMEOUT Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) Test timed out
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>-NOTRUN Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey])
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.js
>deleted file mode 100644
>index 4b3538da689681ceb504f34ca8b0066cf36131c5..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["RSA-OAEP"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..ea91c8f99b04522c519d32e81f80a9ecc5781ae7
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.js
>@@ -0,0 +1,9 @@
>+// META: timeout=long
>+// META: variant=?1-10
>+// META: variant=?11-20
>+// META: variant=?21-30
>+// META: variant=?31-last
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["RSA-PSS"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..79d777e6605a876613b8e540c8076845b33424e3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt
>deleted file mode 100644
>index 459748b9835082e4a3d27bdda79f59e8cacbbf54..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt
>+++ /dev/null
>@@ -1,38 +0,0 @@
>-
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.js
>deleted file mode 100644
>index 52364f5c7f55b701988cb86a1e3f5f4716a0d2d6..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["RSA-PSS"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f58d695d247ddff18e05be392a212e7087f5e05
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: line 80: ReferenceError: Can't find variable: subsetTest
>+
>+FAIL Untitled ReferenceError: Can't find variable: subsetTest
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..fc785f9b31c96a04f12c1d4917d4b274694d8f43
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.js
>@@ -0,0 +1,9 @@
>+// META: timeout=long
>+// META: variant=?1-10
>+// META: variant=?11-20
>+// META: variant=?21-30
>+// META: variant=?31-last
>+// META: script=../util/helpers.js
>+// META: script=/common/subset-tests.js
>+// META: script=successes.js
>+run_test(["RSASSA-PKCS1-v1_5"]);
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..48dea55f480f2880aef1b56a561640e131af48f3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker-expected.txt
>@@ -0,0 +1,4 @@
>+
>+Harness Error (FAIL), message = Error in remote https://localhost:9443/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker.js: NetworkError: Failed to load script
>+
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker-expected.txt
>deleted file mode 100644
>index 7787e3b7af26be3edeee8b5ba27ece86a042ec1a..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker-expected.txt
>+++ /dev/null
>@@ -1,38 +0,0 @@
>-
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.html
>deleted file mode 100644
>index 2382913528e693b3a5d56c660a45060980b548c3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.html
>+++ /dev/null
>@@ -1 +0,0 @@
>-
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.js b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.js
>deleted file mode 100644
>index 4c6a02a98c6251de783e63819409dde205653abc..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.js
>+++ /dev/null
>@@ -1,7 +0,0 @@
>-// META: timeout=long
>-importScripts("/resources/testharness.js");
>-importScripts("../util/helpers.js");
>-importScripts("successes.js");
>-
>-run_test(["RSASSA-PKCS1-v1_5"]);
>-done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https-expected.txt
>deleted file mode 100644
>index 8a27e463c63a3915b24c938dfeb7c0d5b0686608..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https.html
>deleted file mode 100644
>index a3054a57a99a6da759d7aa31cc88f7c1f60ae57a..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test("AES-CBC");
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr-expected.txt
>deleted file mode 100644
>index 5345ac939529c1fefdb61782903282d958b2fd80..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https-expected.txt
>deleted file mode 100644
>index 5345ac939529c1fefdb61782903282d958b2fd80..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https.html
>deleted file mode 100644
>index bb1abf0d948e893ae30508ee7592169fd6db5a87..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test("AES-CTR");
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC-expected.txt
>deleted file mode 100644
>index 3ed002b291ef685c3410b2b87c9008d02c3ebe4d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https-expected.txt
>deleted file mode 100644
>index 3ed002b291ef685c3410b2b87c9008d02c3ebe4d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CBC}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CBC}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https.html
>deleted file mode 100644
>index 7650908c09a157eb907ea1169c3a76e232229f2c..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-CBC"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR-expected.txt
>deleted file mode 100644
>index 9b2965260d65eff087d35876a19f79f0f7bba5e0..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https-expected.txt
>deleted file mode 100644
>index 9b2965260d65eff087d35876a19f79f0f7bba5e0..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-CTR}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-CTR}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https.html
>deleted file mode 100644
>index f08737c390a414f465e0e6cd715da9773c5fb233..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-CTR"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM-expected.txt
>deleted file mode 100644
>index 9afa5c3747de79559ed7f032671c153b8edc9836..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https-expected.txt
>deleted file mode 100644
>index 9afa5c3747de79559ed7f032671c153b8edc9836..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https-expected.txt
>+++ /dev/null
>@@ -1,742 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-GCM}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-GCM}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https.html
>deleted file mode 100644
>index 4ef6a7771025b0be26f37b9ffcbc88e1146e51f9..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-GCM"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW-expected.txt
>deleted file mode 100644
>index 1aac369c2d1dc7223940f4f986e7e58af4507fa9..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW-expected.txt
>+++ /dev/null
>@@ -1,484 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https-expected.txt
>deleted file mode 100644
>index 1aac369c2d1dc7223940f4f986e7e58af4507fa9..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https-expected.txt
>+++ /dev/null
>@@ -1,484 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({length: 128, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, encrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, decrypt]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 64, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 127, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 129, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 255, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 257, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, []) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({length: 512, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 128, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 192, name: AES-KW}, true, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, false, []) 
>-PASS Empty usages: generateKey({length: 256, name: AES-KW}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https.html
>deleted file mode 100644
>index 7cbb4f8bf036455a88ef1fe31dbfddfc17ae1bf5..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-KW"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https-expected.txt
>deleted file mode 100644
>index 2ec0423b8ed4ffc0fb3af81fd22a83533c9bacb5..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https-expected.txt
>+++ /dev/null
>@@ -1,444 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({name: ECDH, namedCurve: P-256}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, sign]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, verify]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: P-512}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits, deriveKey]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDH, namedCurve: Curve25519}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, false, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-256}, true, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, false, []) 
>-PASS Empty usages: generateKey({name: ECDH, namedCurve: P-384}, true, []) 
>-FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-FAIL Empty usages: generateKey({name: ECDH, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https.html
>deleted file mode 100644
>index c606a5b9041c146e760b8cd9f9ccd738f3f990af..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["ECDH"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA-expected.txt
>deleted file mode 100644
>index 02ae363500d54aa52db17f9d78915037aa5cd26b..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA-expected.txt
>+++ /dev/null
>@@ -1,422 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({name: ECDSA, namedCurve: P-256}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign, verify, sign, sign, verify]) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, true, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, true, []) 
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https-expected.txt
>deleted file mode 100644
>index 02ae363500d54aa52db17f9d78915037aa5cd26b..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https-expected.txt
>+++ /dev/null
>@@ -1,422 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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({name: ECDSA, namedCurve: P-256}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: P-512}, true, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, []) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({name: ECDSA, namedCurve: Curve25519}, true, [sign, verify, sign, sign, verify]) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-256}, true, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, false, []) 
>-PASS Empty usages: generateKey({name: ECDSA, namedCurve: P-384}, true, []) 
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, false, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-FAIL Empty usages: generateKey({name: ECDSA, namedCurve: P-521}, true, []) assert_equals: Empty usages not supported expected "SyntaxError" but got "NotSupportedError"
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https.html
>deleted file mode 100644
>index 8b742e80b1e1b709f6902552f6ac814ea1ff965f..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["ECDSA"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC-expected.txt
>deleted file mode 100644
>index 9ad9d91d65950dd55f1a506c9d15fd64faab92be..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC-expected.txt
>+++ /dev/null
>@@ -1,456 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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, length: 160, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https-expected.txt
>deleted file mode 100644
>index 9ad9d91d65950dd55f1a506c9d15fd64faab92be..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https-expected.txt
>+++ /dev/null
>@@ -1,456 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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, length: 160, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify, deriveBits]) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https.html
>deleted file mode 100644
>index e037f0d07d55cdde38a22ed2e9fd89e8cb31d3f3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["HMAC"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https-expected.txt
>deleted file mode 100644
>index e80c3f82fb6b13ddc3af85b8ecf0660c98d7429d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https-expected.txt
>+++ /dev/null
>@@ -1,500 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, sign]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, verify]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey, deriveBits]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, encrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, decrypt]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey, wrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https.html
>deleted file mode 100644
>index ddd63beb343022461efb02347acc706715173c64..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSA-OAEP"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https-expected.txt
>deleted file mode 100644
>index 67730a3966acc70d2fa9b16c17799a781dc17acf..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https-expected.txt
>+++ /dev/null
>@@ -1,396 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https.html
>deleted file mode 100644
>index 2814b34e9a443d29a05cd01bf47bf5e9a1bdfee0..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSA-PSS"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https-expected.txt
>deleted file mode 100644
>index 1260d4fd2b885143e858966cbfaa77e1efb1022e..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https-expected.txt
>+++ /dev/null
>@@ -1,396 +0,0 @@
>-generateKey Tests for Bad Parameters
>-
>-
>-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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, encrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, decrypt]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, wrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, unwrapKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify, deriveKey]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign, deriveBits]) 
>-PASS Bad usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, 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: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [verify, sign]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, []) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Bad algorithm property: generateKey({hash: SHA-256, modulusLength: 1024, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 0}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, []) 
>-PASS Empty usages: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, []) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https.html
>deleted file mode 100644
>index 0e28914af806939833b8f0f08901be0baabd0bb8..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https.html
>+++ /dev/null
>@@ -1,18 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() for Failures</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="failures.js"></script>
>-
>-<h1>generateKey Tests for Bad Parameters</h1>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSASSA-PKCS1-v1_5"]);
>-</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC-expected.txt
>deleted file mode 100644
>index 8a27e463c63a3915b24c938dfeb7c0d5b0686608..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https-expected.txt
>deleted file mode 100644
>index 8a27e463c63a3915b24c938dfeb7c0d5b0686608..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CBC}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-cbc}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https.html
>deleted file mode 100644
>index af809353900783157f64f547b7c9b652fca53a23..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-CBC"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR-expected.txt
>deleted file mode 100644
>index 5345ac939529c1fefdb61782903282d958b2fd80..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https-expected.txt
>deleted file mode 100644
>index 5345ac939529c1fefdb61782903282d958b2fd80..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-CTR}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-ctr}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https.html
>deleted file mode 100644
>index 3608a4fde35bf7cae0158ba6e51cc88b7a8daa0d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-CTR"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https-expected.txt
>deleted file mode 100644
>index 6654b6071ad5e8b3b41b8c1fc9dd0bc5e4cbe9d6..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https-expected.txt
>+++ /dev/null
>@@ -1,294 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-GCM}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, false, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-gcm}, true, [encrypt, decrypt, wrapKey, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https.html
>deleted file mode 100644
>index eb7c6b5d006945a90684c169b016ed74463364f3..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-GCM"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https-expected.txt
>deleted file mode 100644
>index 324ee593ba0bdf85049befdec816e75ee2c6a866..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https-expected.txt
>+++ /dev/null
>@@ -1,78 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: AES-KW}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 128, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 192, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, false, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({length: 256, name: Aes-kw}, true, [wrapKey, unwrapKey, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https.html
>deleted file mode 100644
>index 9beab20834660d775d6cd9982700f7da169a3566..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["AES-KW"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH-expected.txt
>deleted file mode 100644
>index 08703dacfa43e2df271b708c2932976f9f70fb7a..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH-expected.txt
>+++ /dev/null
>@@ -1,78 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The algorithm is not supported Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https-expected.txt
>deleted file mode 100644
>index 7138a1f001fd0a41ddafeb086a148d176031fdda..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https-expected.txt
>+++ /dev/null
>@@ -1,78 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ECDH, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDH, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-256}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits, deriveKey]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-PASS Success: generateKey({name: Ecdh, namedCurve: P-384}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) 
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits, deriveKey]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, false, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdh, namedCurve: P-521}, true, [deriveKey, deriveBits, deriveKey, deriveBits, deriveKey, deriveBits]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https.html
>deleted file mode 100644
>index 9871f572b05c0fd040b4cc85ba964b8093728862..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["ECDH"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https-expected.txt
>deleted file mode 100644
>index 998c81dedc0b4e86fcddc9e00eafcc6099958492..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https-expected.txt
>+++ /dev/null
>@@ -1,60 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ECDSA, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ECDSA, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: ecdsa, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: ecdsa, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-256}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [verify, sign]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({name: Ecdsa, namedCurve: P-384}, true, [sign, verify, sign, sign, verify]) 
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-FAIL Success: generateKey({name: Ecdsa, namedCurve: P-521}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The algorithm is not supported Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https.html
>deleted file mode 100644
>index f32a556bb24ac6b37aa6353f9bf5c8e474683595..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["ECDSA"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https-expected.txt
>deleted file mode 100644
>index 66e9c82c3bbecdb166857a98623fba5f3413aafd..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https-expected.txt
>+++ /dev/null
>@@ -1,102 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: HMAC}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, length: 160, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, length: 256, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-384, length: 384, name: Hmac}, true, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, false, [sign, verify, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-512, length: 512, name: Hmac}, true, [sign, verify, sign, verify]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https.html
>deleted file mode 100644
>index 819b35df08c5185104fc8284cd915c9d91a5ba26..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["HMAC"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https-expected.txt
>deleted file mode 100644
>index 4abad5cbb953cede0e4b0f6169ac5039517cb892..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https-expected.txt
>+++ /dev/null
>@@ -1,162 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-OAEP, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, encrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, decrypt]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey, wrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-oaep, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [encrypt, decrypt, wrapKey, unwrapKey, decrypt, unwrapKey, encrypt, decrypt, wrapKey, unwrapKey]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html
>deleted file mode 100644
>index db58fd6690ab4884525af6918e53392ff9326e6d..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSA-OAEP"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS-expected.txt
>deleted file mode 100644
>index e02cb0683bfc271dd5531f8afd6096e56567af40..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS-expected.txt
>+++ /dev/null
>@@ -1,42 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError (DOM Exception 9): The operation is not supported. Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https-expected.txt
>deleted file mode 100644
>index d9f9e4a26485c327c57a877404529503e06619f9..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https-expected.txt
>+++ /dev/null
>@@ -1,42 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-FAIL Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) assert_unreached: Threw an unexpected error: NotSupportedError: The operation is not supported. Reached unreachable code
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https.html
>deleted file mode 100644
>index d6a3c1b02d0c650aecad3f52ee62f2754512612c..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSA-PSS"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https-expected.txt
>deleted file mode 100644
>index 07e6dc777d4b3ecc596834e9b3b0fd6c7886c0ef..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https-expected.txt
>+++ /dev/null
>@@ -1,42 +0,0 @@
>-generateKey Tests for Good Parameters
>-
>-Warning! RSA key generation is intrinsically very slow, so the related tests can take up to several minutes to complete, depending on browser!
>-
>-
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSASSA-PKCS1-V1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsassa-pkcs1-v1_5, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https.html b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https.html
>deleted file mode 100644
>index 35678798bdf77762a771e411bcb6c5619ca47df1..0000000000000000000000000000000000000000
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https.html
>+++ /dev/null
>@@ -1,23 +0,0 @@
>-<!DOCTYPE html>
>-<meta charset=utf-8>
>-<meta name="timeout" content="long">
>-<title>WebCryptoAPI: generateKey() Successful Calls</title>
>-<link rel="author" title="Charles Engelke" href="mailto:w3c@engelke.com">
>-<link rel="help" href="https://www.w3.org/TR/WebCryptoAPI/#dfn-SubtleCrypto-method-generateKey">
>-<script src="/resources/testharness.js"></script>
>-<script src="/resources/testharnessreport.js"></script>
>-
>-<script src="/WebCryptoAPI/util/helpers.js"></script>
>-<script src="successes.js"></script>
>-
>-<h1>generateKey Tests for Good Parameters</h1>
>-<p>
>-    <strong>Warning!</strong> RSA key generation is intrinsically
>-    very slow, so the related tests can take up to
>-    several minutes to complete, depending on browser!
>-</p>
>-
>-<div id="log"></div>
>-<script>
>-run_test(["RSASSA-PKCS1-v1_5"]);
>-</script>
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/w3c-import.log
>index c78228a7490826e002f2ac5f1b2a2e3f49a2b100..6d42c6bad61a26dc0ae9b4e20f961cb9123c16ec 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/w3c-import.log
>@@ -15,46 +15,24 @@ None
> ------------------------------------------------------------------------
> List of files:
> /LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.worker.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CBC.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-CTR.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-GCM.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_AES-KW.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDH.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_ECDSA.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_HMAC.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-OAEP.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSASSA-PKCS1-v1_5.https.any.js
> /LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.worker.js
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-cbc.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_aes-ctr.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CBC.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-CTR.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-GCM.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_AES-KW.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDH.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_ECDSA.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_HMAC.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSA-PSS.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CBC.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-CTR.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-GCM.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_AES-KW.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDH.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_ECDSA.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_HMAC.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSA-PSS.https.html
>-/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.https.html
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CBC.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-CTR.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-GCM.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_AES-KW.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDH.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_ECDSA.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_HMAC.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-OAEP.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.any.js
>+/LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSASSA-PKCS1-v1_5.https.any.js
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f13d3be0ee02768f3123f06d67505f61ce661441
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object-expected.txt
>@@ -0,0 +1,5 @@
>+
>+PASS Default iterator objects for an interface have the same prototype 
>+PASS Object.prototype.toString returns correct value 
>+FAIL @@toStringTag has correct value from prototype assert_equals: expected (string) "URLSearchParams Iterator" but got (undefined) undefined
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object.html b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..c7e9188521a2ae0bc9f15ff9bcaefc55a5253ce2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object.html
>@@ -0,0 +1,27 @@
>+<!doctype html>
>+<meta charset="utf-8">
>+<title>Default iterator objects</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+test(() => {
>+  const iterator1 = new URLSearchParams()[Symbol.iterator]();
>+  const iterator2 = new URLSearchParams().keys();
>+  const iterator3 = new URLSearchParams().values();
>+  const iterator4 = new URLSearchParams().entries();
>+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator2));
>+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator3));
>+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator4));
>+}, "Default iterator objects for an interface have the same prototype");
>+
>+test(() => {
>+  const iterator = new URLSearchParams().entries();
>+  assert_equals(Object.prototype.toString.call(iterator), "[object URLSearchParams Iterator]");
>+}, "Object.prototype.toString returns correct value");
>+
>+test(() => {
>+  const iterator = new URLSearchParams().entries();
>+  assert_equals(iterator[Symbol.toStringTag], "URLSearchParams Iterator");
>+  assert_equals(Object.getOwnPropertyDescriptor(iterator, Symbol.toStringTag), undefined);
>+}, "@@toStringTag has correct value from prototype");
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..7f321fbfc29e538dc4d00fb8f20d00f29cd1c3c5
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object-expected.txt
>@@ -0,0 +1,8 @@
>+
>+PASS Has %IteratorPrototype% as prototype 
>+PASS next() exists and is writable, enumerable, and configurable 
>+PASS next() throws TypeError when called on ineligible receiver 
>+PASS Object.prototype.toString returns correct value 
>+FAIL @@toStringTag has correct value undefined is not an object (evaluating 'Object.getOwnPropertyDescriptor(iteratorProto, Symbol.toStringTag).value')
>+PASS Is specific to an interface 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object.html b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..5a935fa20135d88a7268b872b68ab7fe548ab5c7
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object.html
>@@ -0,0 +1,56 @@
>+<!doctype html>
>+<meta charset="utf-8">
>+<title>Iterator prototype objects</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+<script>
>+test(() => {
>+  const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
>+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
>+  assert_equals(Object.getPrototypeOf(iteratorProto), esIteratorPrototype);
>+}, "Has %IteratorPrototype% as prototype");
>+
>+test(() => {
>+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
>+  const desc = Object.getOwnPropertyDescriptor(iteratorProto, "next");
>+  assert_equals(typeof desc.value, "function");
>+  assert_equals(desc.writable, true);
>+  assert_equals(desc.enumerable, true);
>+  assert_equals(desc.configurable, true);
>+}, "next() exists and is writable, enumerable, and configurable");
>+
>+test(() => {
>+  const usp = new URLSearchParams();
>+  const iteratorProto = Object.getPrototypeOf(usp.entries());
>+
>+  assert_throws(new TypeError(), () => {
>+    iteratorProto.next();
>+  });
>+  assert_throws(new TypeError(), () => {
>+    iteratorProto.next.call(undefined);
>+  });
>+  assert_throws(new TypeError(), () => {
>+    iteratorProto.next.call(42);
>+  });
>+  assert_throws(new TypeError(), () => {
>+    iteratorProto.next.call(new Headers().entries());
>+  });
>+}, "next() throws TypeError when called on ineligible receiver");
>+
>+test(() => {
>+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
>+  assert_equals(Object.prototype.toString.call(iteratorProto), "[object URLSearchParams Iterator]");
>+}, "Object.prototype.toString returns correct value");
>+
>+test(() => {
>+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
>+  assert_equals(Object.getOwnPropertyDescriptor(iteratorProto, Symbol.toStringTag).value, "URLSearchParams Iterator");
>+  // Property attributes have not yet been fully spec'd.
>+}, "@@toStringTag has correct value");
>+
>+test(() => {
>+  const iteratorProto1 = Object.getPrototypeOf(new URLSearchParams().entries());
>+  const iteratorProto2 = Object.getPrototypeOf(new Headers().entries());
>+  assert_not_equals(iteratorProto1, iteratorProto2);
>+}, "Is specific to an interface");
>+</script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..00dda562a881688680b43b1daba9e1725c93e4c2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any-expected.txt
>@@ -0,0 +1,6 @@
>+
>+PASS Conversion to a dictionary works 
>+PASS Conversion to a sequence works 
>+PASS Can convert a RegExp to a USVString 
>+PASS Can be used as an object implementing a callback interface 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.html b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.js b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..4446dbf69c02ab466ad03fd69d6ed3924d8e84a0
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.js
>@@ -0,0 +1,47 @@
>+"use strict";
>+// RegExps used to be special-cased in Web IDL, but that was removed in
>+// https://github.com/heycam/webidl/commit/bbb2bde. These tests check that implementations no longer
>+// do any such special-casing.
>+
>+test(() => {
>+  const regExp = new RegExp();
>+  regExp.message = "some message";
>+
>+  const errorEvent = new ErrorEvent("type", regExp);
>+
>+  assert_equals(errorEvent.message, "some message");
>+}, "Conversion to a dictionary works");
>+
>+test(() => {
>+  const messageChannel = new MessageChannel();
>+  const regExp = new RegExp();
>+  regExp[Symbol.iterator] = function* () {
>+    yield messageChannel.port1;
>+  };
>+
>+  const messageEvent = new MessageEvent("type", { ports: regExp });
>+
>+  assert_array_equals(messageEvent.ports, [messageChannel.port1]);
>+}, "Conversion to a sequence works");
>+
>+promise_test(async () => {
>+  const regExp = new RegExp();
>+
>+  const response = new Response(regExp);
>+
>+  assert_equals(await response.text(), "/(?:)/");
>+}, "Can convert a RegExp to a USVString");
>+
>+test(() => {
>+  let functionCalled = false;
>+
>+  const regExp = new RegExp();
>+  regExp.handleEvent = () => {
>+    functionCalled = true;
>+  };
>+
>+  self.addEventListener("testevent", regExp);
>+  self.dispatchEvent(new Event("testevent"));
>+
>+  assert_true(functionCalled);
>+}, "Can be used as an object implementing a callback interface");
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..00dda562a881688680b43b1daba9e1725c93e4c2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker-expected.txt
>@@ -0,0 +1,6 @@
>+
>+PASS Conversion to a dictionary works 
>+PASS Conversion to a sequence works 
>+PASS Can convert a RegExp to a USVString 
>+PASS Can be used as an object implementing a callback interface 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker.html b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2382913528e693b3a5d56c660a45060980b548c3
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.worker.html
>@@ -0,0 +1 @@
>+
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/w3c-import.log
>index f271c5ff8b58a0dd25b21056d0510fd7eace9cab..2df80d5462dbabc72362b29b68e20c91bbee5a3f 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/w3c-import.log
>@@ -14,10 +14,13 @@ Property values requiring vendor prefixes:
> None
> ------------------------------------------------------------------------
> List of files:
>+/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/default-iterator-object.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/has-instance.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/interface-object.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/interface-prototype-object.html
>+/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/iterator-prototype-object.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/legacy-callback-interface-object.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/legacy-platform-object.html
>+/LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/no-regexp-special-casing.any.js
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/put-forwards.html
> /LayoutTests/imported/w3c/web-platform-tests/WebIDL/ecmascript-binding/sequence-conversion.html
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.html b/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.html
>index f512e45407125061d2f3aee70eb6f9192774d638..51e320e64379f0af8323aebaf3552cef8f244914 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.html
>@@ -12,15 +12,17 @@
> <script>
> 'use strict';
> 
>-promise_test(function() {
>-  return fetch('/interfaces/background-fetch.idl')
>-    .then(response => response.text())
>-    .then(idls => {
>-      var idlArray = new IdlArray();
>-      idlArray.add_untested_idls('interface ServiceWorkerRegistration {};');
>-      idlArray.add_untested_idls('[Exposed=ServiceWorker] interface ServiceWorkerGlobalScope {};');
>-      idlArray.add_idls(idls);
>-      idlArray.test();
>-    });
>+promise_test(async function () {
>+  const idls = await fetch('/interfaces/background-fetch.idl').then(r => r.text());
>+  const dom = await fetch('/interfaces/dom.idl').then(r => r.text());
>+
>+  var idlArray = new IdlArray();
>+  idlArray.add_untested_idls('interface ServiceWorkerRegistration {};');
>+  idlArray.add_untested_idls('[Exposed=ServiceWorker] interface ServiceWorkerGlobalScope {};');
>+  idlArray.add_untested_idls('interface ExtendableEvent{};');
>+  idlArray.add_untested_idls('dictionary ExtendableEventInit{};');
>+  idlArray.add_untested_idls(dom, { only: ['EventTarget'] });
>+  idlArray.add_idls(idls);
>+  idlArray.test();
> }, 'Exposed interfaces in a Document.');
> </script>
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.worker.js b/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.worker.js
>index 89a7cb3da0ad7310f5c0226f2a3b695c740ef4dd..0760ffd59af52a1125eb49e55107d8943b18212d 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.worker.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/background-fetch/interfaces.worker.js
>@@ -3,16 +3,18 @@
> importScripts('/resources/testharness.js');
> importScripts('/resources/WebIDLParser.js', '/resources/idlharness.js');
> 
>-promise_test(function() {
>-  return fetch('/interfaces/background-fetch.idl')
>-    .then(response => response.text())
>-    .then(idls => {
>-      var idlArray = new IdlArray();
>-      idlArray.add_untested_idls('interface ServiceWorkerRegistration {};');
>-      idlArray.add_untested_idls('[Exposed=ServiceWorker] interface ServiceWorkerGlobalScope {};');
>-      idlArray.add_idls(idls);
>-      idlArray.test();
>-    });
>+promise_test(async function() {
>+  const idls = await fetch('/interfaces/background-fetch.idl').then(r => r.text());
>+  const dom = await fetch('/interfaces/dom.idl').then(r => r.text());
>+
>+  var idlArray = new IdlArray();
>+  idlArray.add_untested_idls('interface ServiceWorkerRegistration {};');
>+  idlArray.add_untested_idls('[SecureContext, Exposed = (Window, Worker)] interface ServiceWorkerGlobalScope {};');
>+  idlArray.add_untested_idls('interface ExtendableEvent{};');
>+  idlArray.add_untested_idls('dictionary ExtendableEventInit{};');
>+  idlArray.add_untested_idls(dom, { only: ['EventTarget'] });
>+  idlArray.add_idls(idls);
>+  idlArray.test();
> }, 'Exposed interfaces in a Service Worker.');
> 
> done();
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/OWNERS b/LayoutTests/imported/w3c/web-platform-tests/beacon/OWNERS
>new file mode 100644
>index 0000000000000000000000000000000000000000..719eb69cf52b28d405ce9dba07d9cac523972368
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/OWNERS
>@@ -0,0 +1,2 @@
>+@toddreifsteck
>+@igrigorik
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-common.sub.js b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-common.sub.js
>index de3846b6cbc9fdfc9dfb55338d7d1bdb84a82abc..0a36283b26379e16ccfd2c33cf05e0395dc18331 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-common.sub.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-common.sub.js
>@@ -39,6 +39,10 @@ var emptyFormDataTest = { id: "EmptyFormData", data: CreateEmptyFormDataPayload(
> var smallFormDataTest = { id: "SmallFormData", data: CreateFormDataFromPayload(smallPayload) };
> var mediumFormDataTest = { id: "MediumFormData", data: CreateFormDataFromPayload(mediumPayload) };
> var largeFormDataTest = { id: "LargeFormData", data: CreateFormDataFromPayload(largePayload) };
>+var smallSafeContentTypeEncodedTest = { id: "SmallSafeContentTypeEncoded", data: new Blob([smallPayload], { type: 'application/x-www-form-urlencoded' }) };
>+var smallSafeContentTypeFormTest = { id: "SmallSafeContentTypeForm", data: new FormData() };
>+var smallSafeContentTypeTextTest = { id: "SmallSafeContentTypeText", data: new Blob([smallPayload], { type: 'text/plain' }) };
>+var smallCORSContentTypeTextTest = { id: "SmallCORSContentTypeText", data: new Blob([smallPayload], { type: 'text/html' }) };
> // We don't test maxFormData because the extra multipart separators make it difficult to
> // calculate a maxPayload.
> 
>@@ -52,12 +56,15 @@ var bufferSourceTests = [emptyBufferSourceTest, smallBufferSourceTest, mediumBuf
> var bufferSourceMaxTest = [maxBufferSourceTest];
> var formDataTests = [emptyFormDataTest, smallFormDataTest, mediumFormDataTest, largeFormDataTest];
> var formDataMaxTest = [largeFormDataTest];
>-var allTests = [].concat(stringTests, stringMaxTest, blobTests, blobMaxTest, bufferSourceTests, bufferSourceMaxTest, formDataTests, formDataMaxTest);
>+var contentTypeTests = [smallSafeContentTypeEncodedTest,smallSafeContentTypeFormTest,smallSafeContentTypeTextTest,smallCORSContentTypeTextTest];
>+var allTests = [].concat(stringTests, stringMaxTest, blobTests, blobMaxTest, bufferSourceTests, bufferSourceMaxTest, formDataTests, formDataMaxTest, contentTypeTests);
> 
> // This special cross section of test cases is meant to provide a slimmer but reasonably-
> // representative set of tests for parameterization across variables (e.g. redirect codes,
> // cors modes, etc.)
>-var sampleTests = [noDataTest, nullDataTest, undefinedDataTest, smallStringTest, smallBlobTest, smallBufferSourceTest, smallFormDataTest];
>+var sampleTests = [noDataTest, nullDataTest, undefinedDataTest, smallStringTest, smallBlobTest, smallBufferSourceTest, smallFormDataTest, smallSafeContentTypeEncodedTest, smallSafeContentTypeFormTest, smallSafeContentTypeTextTest];
>+
>+var preflightTests = [smallCORSContentTypeTextTest];
> 
> // Build a test lookup table, which is useful when instructing a web worker or an iframe
> // to run a test, so that we don't have to marshal the entire test case across a process boundary.
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-cors.sub.window.js b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-cors.sub.window.js
>index ddfdfbfa0a2796ac4bd2f9355ad7e1faa52046cf..f4bccf177e3b4585a5efe0b6cd0d6edc24fe48f9 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-cors.sub.window.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-cors.sub.window.js
>@@ -38,4 +38,30 @@
>     runTests(sampleTests);
> });
> 
>+// Now test a cross-origin request that doesn't use a safelisted Content-Type and ensure
>+// we are applying the proper restrictions. Since a non-safelisted Content-Type request
>+// header is used there should be a preflight/options request and we should only succeed
>+// send the payload if the proper CORS headers are used.
>+{
>+    // Implement the self.buildId extension to identify the parameterized
>+    // test in the report.
>+    self.buildId = function (baseId) {
>+        return `${baseId}-PREFLIGHT-ALLOW`;
>+    };
>+
>+    // Implement the self.buildBaseUrl and self.buildTargetUrl extensions
>+    // to change the target URL to use a cross-origin domain name.
>+    self.buildBaseUrl = function (baseUrl) {
>+        return "http://{{domains[www]}}:{{ports[http][0]}}";
>+    };
>+
>+    // Implement the self.buildTargetUrl extension to append a directive
>+    // to the handler, that it should return CORS headers for the preflight we expect.
>+    self.buildTargetUrl = function (targetUrl) {
>+        return `${targetUrl}&origin=http://{{host}}:{{ports[http][0]}}&credentials=true&preflightExpected=true`;
>+    }
>+
>+    runTests(preflightTests);
>+}
>+
> done();
>\ No newline at end of file
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-error.window.js b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-error.window.js
>index 9c037ba34f6d10bd55e007d6cf7fb74082aa6944..b53353abc1ea29679216488ef17c9c9a010a434d 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-error.window.js
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-error.window.js
>@@ -24,16 +24,25 @@ test(function() {
> }, "Verify calling 'navigator.sendBeacon()' with a URL that is not a http(s) scheme throws an exception.");
> 
> // We'll validate that we can send one beacon that uses our entire Quota and then fail to send one that is just one char.
>-test(function () {
>-    var destinationURL = "/fetch/api/resources/trickle.py?count=1&ms=1000";
>-
>-    var firstSuccess = navigator.sendBeacon(destinationURL, maxPayload);
>-    assert_true(firstSuccess, "calling 'navigator.sendBeacon()' with our max payload size should succeed.");
>+promise_test(async () => {
>+    function wait(ms) {
>+        return new Promise(res => step_timeout(res, ms));
>+    }
>+    const url = '/fetch/api/resources/trickle.py?count=1&ms=0';
>+    assert_true(navigator.sendBeacon(url, maxPayload),
>+                "calling 'navigator.sendBeacon()' with our max payload size should succeed.");
> 
>     // Now we'll send just one character.
>-    var secondSuccess = navigator.sendBeacon(destinationURL, "1");
>-    assert_false(secondSuccess, "calling 'navigator.sendBeacon()' with just one char should fail while our Quota is used up.");
>-
>-}, "Verify calling 'navigator.sendBeacon()' with a small payload fails while Quota is completely utilized.");
>+    assert_false(navigator.sendBeacon(url, '1'),
>+                 "calling 'navigator.sendBeacon()' with just one char should fail while our Quota is used up.");
>+
>+    for (let i = 0; i < 20; ++i) {
>+        await wait(100);
>+        if (navigator.sendBeacon(url, maxPayload)) {
>+           return;
>+        }
>+    }
>+    assert_unreached('The quota should recover after fetching.');
>+}, "Verify the behavior after the quota is exhausted.");
> 
> done();
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-navigate-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-navigate-expected.txt
>index 7abb6d26da0ea57ff58046c223dca331059421ae..d5450c0b7fecf3c3318fe0e623cf6977f7df4e4a 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-navigate-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-navigate-expected.txt
>@@ -7,4 +7,7 @@ PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallString
> PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallBlob-beacon-NAVIGATE 
> PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallBufferSource-beacon-NAVIGATE 
> PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallFormData-beacon-NAVIGATE 
>+PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallSafeContentTypeEncoded-beacon-NAVIGATE 
>+PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallSafeContentTypeForm-beacon-NAVIGATE 
>+PASS Verify 'navigator.sendbeacon()' successfully sends for variant: SmallSafeContentTypeText-beacon-NAVIGATE 
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/headers/header-content-type.html b/LayoutTests/imported/w3c/web-platform-tests/beacon/headers/header-content-type.html
>index 2d23adfb712c4488ca6b64a406b0a181a05fe6c0..e2f2705ee64943cc595a1cc12488270db83c40fc 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/headers/header-content-type.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/headers/header-content-type.html
>@@ -10,36 +10,30 @@
>     <script src="/common/utils.js"></script>
>     <script src="/common/get-host-info.sub.js"></script>
>     <script>
>-var RESOURCES_DIR = "/beacon/resources/";
>-
>-function pollResult(test, id) {
>-  var checkUrl = RESOURCES_DIR + "content-type.py?cmd=get&id=" + id;
>-
>-  return new Promise(resolve => {
>-    step_timeout(test.step_func(() => {
>-      fetch(checkUrl).then(response => {
>-        response.text().then(body => {
>-          resolve(body);
>-        });
>-      });
>-    }), 1000);
>-  });
>-}
>+const RESOURCES_DIR = "/beacon/resources/";
> 
> function testContentTypeHeader(what, contentType, title) {
>-  var testBase = RESOURCES_DIR;
>-  var id = self.token();
>-  var testUrl = testBase + "content-type.py?cmd=put&id=" + id;
>-
>-  promise_test(function(test) {
>+  function wait(ms) {
>+    return new Promise(resolve => step_timeout(resolve, ms));
>+  }
>+  promise_test(async t => {
>+    const id = self.token();
>+    const testUrl = new Request(RESOURCES_DIR + "content-type.py?cmd=put&id=" + id).url;
>+    assert_equals(performance.getEntriesByName(testUrl).length, 0);
>     assert_true(navigator.sendBeacon(testUrl, what), "SendBeacon Succeeded");
>-    return pollResult(test, id) .then(result => {
>-      if (contentType == "multipart/form-data") {
>-        assert_true(result.startsWith(contentType), "Correct Content-Type header result");
>-      } else {
>-        assert_equals(result, contentType, "Correct Content-Type header result");
>-      }
>-    });
>+
>+    do {
>+      await wait(50);
>+    } while (performance.getEntriesByName(testUrl).length === 0);
>+    assert_equals(performance.getEntriesByName(testUrl).length, 1);
>+    const checkUrl = RESOURCES_DIR + "content-type.py?cmd=get&id=" + id;
>+    const response = await fetch(checkUrl);
>+    const text = await response.text();
>+    if (contentType === "multipart/form-data") {
>+      assert_true(text.startsWith(contentType), "Correct Content-Type header result");
>+    } else {
>+      assert_equals(text, contentType, "Correct Content-Type header result");
>+    }
>   }, "Test content-type header for a body " + title);
> }
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/resources/beacon.py b/LayoutTests/imported/w3c/web-platform-tests/beacon/resources/beacon.py
>index afa522a2a91707fcbf9dcc4845296399afb2bafa..5f2553d3c4d506f7e292cfb73d81930a83a12d76 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/resources/beacon.py
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/resources/beacon.py
>@@ -60,40 +60,52 @@ def main(request, response):
>         # with the unique session id, in order to retrieve a range of results
>         # later knowing the index range.
>         test_idx = request.GET.first("tidx")
>-
>-        test_data_key = build_stash_key(session_id, test_idx)
>         test_data = { "id": test_id, "error": None }
> 
>-        payload = ""
>-        if "Content-Type" in request.headers and \
>-           "form-data" in request.headers["Content-Type"]:
>-            if "payload" in request.POST:
>-                # The payload was sent as a FormData.
>-                payload = request.POST.first("payload")
>+        # Only store the actual POST requests, not any preflight/OPTIONS requests we may get.
>+        if request.method == "POST":
>+            test_data_key = build_stash_key(session_id, test_idx)
>+
>+            payload = ""
>+            if "Content-Type" in request.headers and \
>+               "form-data" in request.headers["Content-Type"]:
>+                if "payload" in request.POST:
>+                    # The payload was sent as a FormData.
>+                    payload = request.POST.first("payload")
>+                else:
>+                    # A FormData was sent with an empty payload.
>+                    pass
>             else:
>-                # A FormData was sent with an empty payload.
>-                pass
>-        else:
>-            # The payload was sent as either a string, Blob, or BufferSource.
>-            payload = request.body
>-
>-        payload_parts = filter(None, payload.split(":"))
>-        if len(payload_parts) > 0:
>-            payload_size = int(payload_parts[0])
>-
>-            # Confirm the payload size sent matches with the number of characters sent.
>-            if payload_size != len(payload_parts[1]):
>-                test_data["error"] = "expected %d characters but got %d" % (payload_size, len(payload_parts[1]))
>+                # The payload was sent as either a string, Blob, or BufferSource.
>+                payload = request.body
>+
>+            payload_parts = filter(None, payload.split(":"))
>+            if len(payload_parts) > 0:
>+                payload_size = int(payload_parts[0])
>+
>+                # Confirm the payload size sent matches with the number of characters sent.
>+                if payload_size != len(payload_parts[1]):
>+                    test_data["error"] = "expected %d characters but got %d" % (payload_size, len(payload_parts[1]))
>+                else:
>+                    # Confirm the payload contains the correct characters.
>+                    for i in range(0, payload_size):
>+                        if payload_parts[1][i] != "*":
>+                            test_data["error"] = "expected '*' at index %d but got '%s''" % (i, payload_parts[1][i])
>+                            break
>+
>+            # Store the result in the stash so that it can be retrieved
>+            # later with a 'stat' command.
>+            request.server.stash.put(test_data_key, test_data)
>+        elif request.method == "OPTIONS":
>+            # If we expect a preflight, then add the cors headers we expect, otherwise log an error as we shouldn't
>+            # send a preflight for all requests.
>+            if "preflightExpected" in request.GET:
>+                response.headers.set("Access-Control-Allow-Headers", "content-type")
>+                response.headers.set("Access-Control-Allow-Methods", "POST")
>             else:
>-                # Confirm the payload contains the correct characters.
>-                for i in range(0, payload_size):
>-                    if payload_parts[1][i] != "*":
>-                        test_data["error"] = "expected '*' at index %d but got '%s''" % (i, payload_parts[1][i])
>-                        break
>-
>-        # Store the result in the stash so that it can be retrieved
>-        # later with a 'stat' command.
>-        request.server.stash.put(test_data_key, test_data)
>+                test_data_key = build_stash_key(session_id, test_idx)
>+                test_data["error"] = "Preflight not expected."
>+                request.server.stash.put(test_data_key, test_data)
>     elif command == "stat":
>         test_idx_min = int(request.GET.first("tidx_min"))
>         test_idx_max = int(request.GET.first("tidx_max"))
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/beacon/w3c-import.log b/LayoutTests/imported/w3c/web-platform-tests/beacon/w3c-import.log
>index e2e1c720f57fd7a383a9bc7ff475de7bee73e699..0887376b09285ffcf707d458db9ee4bec630ceee 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/beacon/w3c-import.log
>+++ b/LayoutTests/imported/w3c/web-platform-tests/beacon/w3c-import.log
>@@ -14,6 +14,7 @@ Property values requiring vendor prefixes:
> None
> ------------------------------------------------------------------------
> List of files:
>+/LayoutTests/imported/w3c/web-platform-tests/beacon/OWNERS
> /LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-basic-blob.html
> /LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-basic-blobMax.html
> /LayoutTests/imported/w3c/web-platform-tests/beacon/beacon-basic-buffersource.html
>diff --git a/LayoutTests/platform/ios/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt b/LayoutTests/platform/ios/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>index 60ee6e5eac9398982e63cc40a81e3f6f626c754a..3d8e9dc55d8ab8f3c81f784e926eb2b296709fb2 100644
>--- a/LayoutTests/platform/ios/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>+++ b/LayoutTests/platform/ios/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>@@ -1,8 +1,10 @@
> 
>-PASS Test content-type header for a body string 
>-PASS Test content-type header for a body ArrayBufferView 
>-PASS Test content-type header for a body ArrayBuffer 
>-PASS Test content-type header for a body Blob 
>-PASS Test content-type header for a body FormData 
>-PASS Test content-type header for a body URLSearchParams 
>+Harness Error (TIMEOUT), message = null
>+
>+TIMEOUT Test content-type header for a body string Test timed out
>+NOTRUN Test content-type header for a body ArrayBufferView 
>+NOTRUN Test content-type header for a body ArrayBuffer 
>+NOTRUN Test content-type header for a body Blob 
>+NOTRUN Test content-type header for a body FormData 
>+NOTRUN Test content-type header for a body URLSearchParams 
> 
>diff --git a/LayoutTests/platform/mac-wk2/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt b/LayoutTests/platform/mac-wk2/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3d8e9dc55d8ab8f3c81f784e926eb2b296709fb2
>--- /dev/null
>+++ b/LayoutTests/platform/mac-wk2/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>@@ -0,0 +1,10 @@
>+
>+Harness Error (TIMEOUT), message = null
>+
>+TIMEOUT Test content-type header for a body string Test timed out
>+NOTRUN Test content-type header for a body ArrayBufferView 
>+NOTRUN Test content-type header for a body ArrayBuffer 
>+NOTRUN Test content-type header for a body Blob 
>+NOTRUN Test content-type header for a body FormData 
>+NOTRUN Test content-type header for a body URLSearchParams 
>+
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..60e441b91d938071f75b2fc9b712803cb936e919
>--- /dev/null
>+++ b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-large-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS 250 cursors 
>+
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..67798bd5c9b97fede4abaf453c069f1dd0893c47
>--- /dev/null
>+++ b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/IndexedDB/interleaved-cursors-small-expected.txt
>@@ -0,0 +1,5 @@
>+
>+PASS 1 cursors 
>+PASS 10 cursors 
>+PASS 100 cursors 
>+
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt
>deleted file mode 100644
>index 037f0956f5d4536ef735ff168015d219d3020a50..0000000000000000000000000000000000000000
>--- a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/failures_RSA-PSS.https.worker-expected.txt
>+++ /dev/null
>@@ -1,394 +0,0 @@
>-
>-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/successes_RSA-PSS.https.worker-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt
>deleted file mode 100644
>index 9cd26079b0c9484e30c3bcfba7d860539d9eab1d..0000000000000000000000000000000000000000
>--- a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/WebCryptoAPI/generateKey/successes_RSA-PSS.https.worker-expected.txt
>+++ /dev/null
>@@ -1,38 +0,0 @@
>-
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: RSA-PSS, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-1, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [verify, sign]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, false, [sign, verify, sign, sign, verify]) 
>-PASS Success: generateKey({hash: SHA-256, modulusLength: 2048, name: Rsa-pss, publicExponent: {0: 1, 1: 0, 2: 1}}, true, [sign, verify, sign, sign, verify]) 
>-
>diff --git a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>index 60ee6e5eac9398982e63cc40a81e3f6f626c754a..3d8e9dc55d8ab8f3c81f784e926eb2b296709fb2 100644
>--- a/LayoutTests/platform/mac/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>+++ b/LayoutTests/platform/mac/imported/w3c/web-platform-tests/beacon/headers/header-content-type-expected.txt
>@@ -1,8 +1,10 @@
> 
>-PASS Test content-type header for a body string 
>-PASS Test content-type header for a body ArrayBufferView 
>-PASS Test content-type header for a body ArrayBuffer 
>-PASS Test content-type header for a body Blob 
>-PASS Test content-type header for a body FormData 
>-PASS Test content-type header for a body URLSearchParams 
>+Harness Error (TIMEOUT), message = null
>+
>+TIMEOUT Test content-type header for a body string Test timed out
>+NOTRUN Test content-type header for a body ArrayBufferView 
>+NOTRUN Test content-type header for a body ArrayBuffer 
>+NOTRUN Test content-type header for a body Blob 
>+NOTRUN Test content-type header for a body FormData 
>+NOTRUN Test content-type header for a body URLSearchParams 
>

Actions: View | Formatted Diff | Diff

Attachments on bug 186267: 342044 | 342050 | 342057 | 342061 | 342064 | 342065 | 342066 | 342073 | 342074 | 342076 | 342078 | 342251 | 342256 | 342257 | 342260 | 342261 | 342275 | 342291 | 342294