Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 13:40:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision a46616a5b18e83587ddbbed756c7b96cbb4b015d

Browse source
This commit is contained in:
Josh Matthews 2017-06-19 19:07:14 -04:00 • committed by Ms2ger
parent 3f07cfec7c
commit 578498ba24
4001 changed files with 159517 additions and 30260 deletions
Download patch file Download diff file Expand all files Collapse all files

36685
tests/wpt/metadata/MANIFEST.json
View file

File diff suppressed because it is too large Load diff

5
tests/wpt/metadata/WebCryptoAPI/derive_bits_keys/test_ecdh_bits.html.ini
View file

@ -1,5 +0,0 @@
[test_ecdh_bits.html]
type: testharness
[WebCryptoAPI: deriveBits() Using ECDH]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/derive_bits_keys/test_ecdh_keys.html.ini
View file

@ -1,5 +0,0 @@
[test_ecdh_keys.html]
type: testharness
[WebCryptoAPI:deriveKey() Using ECDH]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/derive_bits_keys/test_hkdf.html.ini
View file

@ -1,5 +0,0 @@
[test_hkdf.html]
type: testharness
[WebCryptoAPI: deriveBits() and deriveKey() Using HKDF]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/derive_bits_keys/test_pbkdf2.html.ini
View file

@ -1,5 +0,0 @@
[test_pbkdf2.html]
type: testharness
[WebCryptoAPI: deriveBits() and deriveKey() Using PBKDF2]
expected: FAIL

242
tests/wpt/metadata/WebCryptoAPI/digest/test_digest.html.ini
View file

@ -1,242 +0,0 @@
[test_digest.html]
type: testharness
[SHA-1 with empty source data]
expected: FAIL
[sha-1 with empty source data]
expected: FAIL
[Sha-1 with empty source data]
expected: FAIL
[SHA-1 with empty source data and altered buffer after call]
expected: FAIL
[SHA-256 with empty source data]
expected: FAIL
[sha-256 with empty source data]
expected: FAIL
[Sha-256 with empty source data]
expected: FAIL
[SHA-256 with empty source data and altered buffer after call]
expected: FAIL
[SHA-384 with empty source data]
expected: FAIL
[sha-384 with empty source data]
expected: FAIL
[Sha-384 with empty source data]
expected: FAIL
[SHA-384 with empty source data and altered buffer after call]
expected: FAIL
[SHA-512 with empty source data]
expected: FAIL
[sha-512 with empty source data]
expected: FAIL
[Sha-512 with empty source data]
expected: FAIL
[SHA-512 with empty source data and altered buffer after call]
expected: FAIL
[SHA-1 with short source data]
expected: FAIL
[sha-1 with short source data]
expected: FAIL
[Sha-1 with short source data]
expected: FAIL
[SHA-1 with short source data and altered buffer after call]
expected: FAIL
[SHA-256 with short source data]
expected: FAIL
[sha-256 with short source data]
expected: FAIL
[Sha-256 with short source data]
expected: FAIL
[SHA-256 with short source data and altered buffer after call]
expected: FAIL
[SHA-384 with short source data]
expected: FAIL
[sha-384 with short source data]
expected: FAIL
[Sha-384 with short source data]
expected: FAIL
[SHA-384 with short source data and altered buffer after call]
expected: FAIL
[SHA-512 with short source data]
expected: FAIL
[sha-512 with short source data]
expected: FAIL
[Sha-512 with short source data]
expected: FAIL
[SHA-512 with short source data and altered buffer after call]
expected: FAIL
[SHA-1 with medium source data]
expected: FAIL
[sha-1 with medium source data]
expected: FAIL
[Sha-1 with medium source data]
expected: FAIL
[SHA-1 with medium source data and altered buffer after call]
expected: FAIL
[SHA-256 with medium source data]
expected: FAIL
[sha-256 with medium source data]
expected: FAIL
[Sha-256 with medium source data]
expected: FAIL
[SHA-256 with medium source data and altered buffer after call]
expected: FAIL
[SHA-384 with medium source data]
expected: FAIL
[sha-384 with medium source data]
expected: FAIL
[Sha-384 with medium source data]
expected: FAIL
[SHA-384 with medium source data and altered buffer after call]
expected: FAIL
[SHA-512 with medium source data]
expected: FAIL
[sha-512 with medium source data]
expected: FAIL
[Sha-512 with medium source data]
expected: FAIL
[SHA-512 with medium source data and altered buffer after call]
expected: FAIL
[SHA-1 with long source data]
expected: FAIL
[sha-1 with long source data]
expected: FAIL
[Sha-1 with long source data]
expected: FAIL
[SHA-1 with long source data and altered buffer after call]
expected: FAIL
[SHA-256 with long source data]
expected: FAIL
[sha-256 with long source data]
expected: FAIL
[Sha-256 with long source data]
expected: FAIL
[SHA-256 with long source data and altered buffer after call]
expected: FAIL
[SHA-384 with long source data]
expected: FAIL
[sha-384 with long source data]
expected: FAIL
[Sha-384 with long source data]
expected: FAIL
[SHA-384 with long source data and altered buffer after call]
expected: FAIL
[SHA-512 with long source data]
expected: FAIL
[sha-512 with long source data]
expected: FAIL
[Sha-512 with long source data]
expected: FAIL
[SHA-512 with long source data and altered buffer after call]
expected: FAIL
[AES-GCM with empty]
expected: FAIL
[RSA-OAEP with empty]
expected: FAIL
[PBKDF2 with empty]
expected: FAIL
[AES-KW with empty]
expected: FAIL
[AES-GCM with short]
expected: FAIL
[RSA-OAEP with short]
expected: FAIL
[PBKDF2 with short]
expected: FAIL
[AES-KW with short]
expected: FAIL
[AES-GCM with medium]
expected: FAIL
[RSA-OAEP with medium]
expected: FAIL
[PBKDF2 with medium]
expected: FAIL
[AES-KW with medium]
expected: FAIL
[AES-GCM with long]
expected: FAIL
[RSA-OAEP with long]
expected: FAIL
[PBKDF2 with long]
expected: FAIL
[AES-KW with long]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/encrypt_decrypt/test_aes_cbc.html.ini
View file

@ -1,5 +0,0 @@
[test_aes_cbc.html]
type: testharness
[WebCryptoAPI: encrypt() Using AES-CBC]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/encrypt_decrypt/test_aes_ctr.html.ini
View file

@ -1,5 +0,0 @@
[test_aes_ctr.html]
type: testharness
[WebCryptoAPI: encrypt() Using AES-CTR]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/encrypt_decrypt/test_aes_gcm.html.ini
View file

@ -1,5 +0,0 @@
[test_aes_gcm.html]
type: testharness
[WebCryptoAPI: encrypt() Using AES-GCM]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/encrypt_decrypt/test_rsa_oaep.html.ini
View file

@ -1,5 +0,0 @@
[test_rsa_oaep.html]
type: testharness
[WebCryptoAPI: encrypt() Using RSA-OAEP]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_aes-cbc.html.ini
View file

@ -1,5 +0,0 @@
[test_aes-cbc.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_aes-ctr.html.ini
View file

@ -1,5 +0,0 @@
[test_aes-ctr.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures.html.ini
View file

@ -1,5 +0,0 @@
[test_failures.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_AES-CBC.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_AES-CBC.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_AES-CTR.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_AES-CTR.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_AES-GCM.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_AES-GCM.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_AES-KW.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_AES-KW.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_ECDH.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_ECDH.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_ECDSA.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_ECDSA.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_HMAC.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_HMAC.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_RSA-OAEP.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_RSA-OAEP.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_RSA-PSS.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_RSA-PSS.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_failures_RSASSA-PKCS1-v1_5.html.ini
View file

@ -1,5 +0,0 @@
[test_failures_RSASSA-PKCS1-v1_5.html]
type: testharness
[WebCryptoAPI: generateKey() for Failures]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes.html.ini
View file

@ -1,5 +0,0 @@
[test_successes.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_AES-CBC.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_AES-CBC.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_AES-CTR.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_AES-CTR.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_AES-GCM.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_AES-GCM.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_AES-KW.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_AES-KW.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_ECDH.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_ECDH.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_ECDSA.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_ECDSA.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_HMAC.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_HMAC.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_RSA-OAEP.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_RSA-OAEP.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_RSA-PSS.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_RSA-PSS.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/generateKey/test_successes_RSASSA-PKCS1-v1_5.html.ini
View file

@ -1,5 +0,0 @@
[test_successes_RSASSA-PKCS1-v1_5.html]
type: testharness
[WebCryptoAPI: generateKey() Successful Calls]
expected: FAIL

218
tests/wpt/metadata/WebCryptoAPI/import_export/test_ec_importKey.html.ini
View file

@ -1,218 +0,0 @@
[test_ec_importKey.html]
type: testharness
[Good parameters: P-256 bits (spki, buffer(91), {name: ECDSA, namedCurve: P-256}, true, [\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-256}, true, [\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDSA, namedCurve: P-256}, true, [sign\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-256}, true, [sign\])]
expected: FAIL
[Good parameters: P-256 bits (spki, buffer(91), {name: ECDSA, namedCurve: P-256}, false, [\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-256}, false, [\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDSA, namedCurve: P-256}, false, [sign\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-256}, false, [sign\])]
expected: FAIL
[Good parameters: P-384 bits (spki, buffer(120), {name: ECDSA, namedCurve: P-384}, true, [\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-384}, true, [\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDSA, namedCurve: P-384}, true, [sign\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-384}, true, [sign\])]
expected: FAIL
[Good parameters: P-384 bits (spki, buffer(120), {name: ECDSA, namedCurve: P-384}, false, [\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-384}, false, [\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDSA, namedCurve: P-384}, false, [sign\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-384}, false, [sign\])]
expected: FAIL
[Good parameters: P-521 bits (spki, buffer(158), {name: ECDSA, namedCurve: P-521}, true, [\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-521}, true, [\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDSA, namedCurve: P-521}, true, [sign\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-521}, true, [sign\])]
expected: FAIL
[Good parameters: P-521 bits (spki, buffer(158), {name: ECDSA, namedCurve: P-521}, false, [\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y), {name: ECDSA, namedCurve: P-521}, false, [\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDSA, namedCurve: P-521}, false, [sign\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDSA, namedCurve: P-521}, false, [sign\])]
expected: FAIL
[Good parameters: P-256 bits (spki, buffer(91), {name: ECDH, namedCurve: P-256}, true, [\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-256}, true, [\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-256 bits (spki, buffer(91), {name: ECDH, namedCurve: P-256}, false, [\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-256}, false, [\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-256 bits (pkcs8, buffer(138), {name: ECDH, namedCurve: P-256}, false, [deriveBits\])]
expected: FAIL
[Good parameters: P-256 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-256}, false, [deriveBits\])]
expected: FAIL
[Good parameters: P-384 bits (spki, buffer(120), {name: ECDH, namedCurve: P-384}, true, [\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-384}, true, [\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-384 bits (spki, buffer(120), {name: ECDH, namedCurve: P-384}, false, [\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-384}, false, [\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-384 bits (pkcs8, buffer(185), {name: ECDH, namedCurve: P-384}, false, [deriveBits\])]
expected: FAIL
[Good parameters: P-384 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-384}, false, [deriveBits\])]
expected: FAIL
[Good parameters: P-521 bits (spki, buffer(158), {name: ECDH, namedCurve: P-521}, true, [\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-521}, true, [\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, true, [deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, true, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, true, [deriveBits\])]
expected: FAIL
[Good parameters: P-521 bits (spki, buffer(158), {name: ECDH, namedCurve: P-521}, false, [\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y), {name: ECDH, namedCurve: P-521}, false, [\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, false, [deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, false, [deriveBits, deriveKey\])]
expected: FAIL
[Good parameters: P-521 bits (pkcs8, buffer(241), {name: ECDH, namedCurve: P-521}, false, [deriveBits\])]
expected: FAIL
[Good parameters: P-521 bits (jwk, object(kty, crv, x, y, d), {name: ECDH, namedCurve: P-521}, false, [deriveBits\])]
expected: FAIL

1442
tests/wpt/metadata/WebCryptoAPI/import_export/test_rsa_importKey.html.ini
View file

File diff suppressed because it is too large Load diff

704
tests/wpt/metadata/WebCryptoAPI/import_export/test_symmetric_importKey.html.ini
View file

@ -1,704 +0,0 @@
[test_symmetric_importKey.html]
type: testharness
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CTR, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CTR, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CTR}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128CBC, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256CBC, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-CBC}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128GCM, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, true, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, false, [encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, true, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, false, [decrypt, encrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, true, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256GCM, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-GCM}, false, [decrypt\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: A128KW, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: A192KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, true, [wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, false, [wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, true, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, false, [unwrapKey, wrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, true, [unwrapKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: A256KW, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {name: AES-KW}, false, [unwrapKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS1, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-1, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS256, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-256, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS384, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-384, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 192 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcY, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify, sign\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 256 bits (jwk, {alg: HS512, k: AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA, kty: oct}, {hash: SHA-512, name: HMAC}, false, [verify\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: HKDF}, false, [deriveKey\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 128 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 192 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveBits\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey, deriveBits\])]
expected: FAIL
[Good parameters: 256 bits (raw, {0: 1, 1: 2, 10: 11, 11: 12, 12: 13, 13: 14, 14: 15, 15: 16, 16: 17, 17: 18, 18: 19, 19: 20, 2: 3, 20: 21, 21: 22, 22: 23, 23: 24, 24: 25, 25: 26, 26: 27, 27: 28, 28: 29, 29: 30, 3: 4, 30: 31, 31: 32, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}, {name: PBKDF2}, false, [deriveKey\])]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/sign_verify/test_ecdsa.html.ini
View file

@ -1,5 +0,0 @@
[test_ecdsa.html]
type: testharness
[WebCryptoAPI: sign() and verify() Using ECDSA]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/sign_verify/test_hmac.html.ini
View file

@ -1,5 +0,0 @@
[test_hmac.html]
type: testharness
[WebCryptoAPI: sign() and verify() Using HMAC]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/sign_verify/test_rsa_pkcs.html.ini
View file

@ -1,5 +0,0 @@
[test_rsa_pkcs.html]
type: testharness
[WebCryptoAPI: sign() and verify() Using RSASSA-PKCS1-v1_5]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/sign_verify/test_rsa_pss.html.ini
View file

@ -1,5 +0,0 @@
[test_rsa_pss.html]
type: testharness
[WebCryptoAPI: sign() and verify() Using RSA-PSS]
expected: FAIL

5
tests/wpt/metadata/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.html.ini
View file

@ -1,5 +0,0 @@
[test_wrapKey_unwrapKey.html]
type: testharness
[WebCryptoAPI: wrapKey() and unwrapKey()]
expected: FAIL

1
tests/wpt/metadata/encoding/legacy-mb-japanese/__dir__.ini Normal file
View file

@ -0,0 +1 @@
disabled: gigantic tests that all fail/timeout

1
tests/wpt/metadata/encoding/legacy-mb-korean/__dir__.ini Normal file
View file

@ -0,0 +1 @@
disabled: gigantic tests that all fail/timeout

1
tests/wpt/metadata/encoding/legacy-mb-tchinese/__dir__.ini Normal file
View file

@ -0,0 +1 @@
disabled: gigantic tests that all fail/timeout

11
tests/wpt/metadata/html/webappapis/scripting/events/event-handler-onauxclick.html.ini
View file

@ -1,11 +0,0 @@
[event-handler-onauxclick.html]
type: testharness
[onauxclick is on the appropriate locations for GlobalEventHandlers]
expected: FAIL
[The default value of onauxclick is always null]
expected: FAIL
[The onauxclick content attribute must be compiled into the onauxclick property]
expected: FAIL

4
tests/wpt/metadata/mozilla-sync
View file

@ -1,2 +1,2 @@
local: 533853fdce029d7184a33f7d08bfce7cbd6248c8 local: 4ecddb0622dcb6fdb7a7bd5025dd12be293b30e1
upstream: a6213478991012d8b1da71a49bb01f013ff71869 upstream: a46616a5b18e83587ddbbed756c7b96cbb4b015d

11
tests/wpt/metadata/url/interfaces.html.ini
View file

@ -1,11 +0,0 @@
[interfaces.html]
type: testharness
[Testing Symbol.iterator property of iterable interface URLSearchParams]
expected: FAIL
[URL interface: operation toJSON()]
expected: FAIL
[URL interface: new URL("http://foo") must inherit property "toJSON" with the proper type (12)]
expected: FAIL

6
tests/wpt/web-platform-tests/.codecov.yml Normal file
View file

@ -0,0 +1,6 @@
comment:
require_changes: yes
ignore:
- "**"
- "!tools/.*"

1
tests/wpt/web-platform-tests/.gitignore vendored
View file

@ -14,3 +14,4 @@ webdriver/.idea
.vscode/ .vscode/
.DS_Store .DS_Store
*.rej *.rej
_venv

14
tests/wpt/web-platform-tests/.gitmodules vendored
View file

@ -1,14 +1,12 @@
[submodule "resources"]
path = resources
url = https://github.com/w3c/testharness.js.git
ignore = dirty
[submodule "tools"]
path = tools
url = https://github.com/w3c/wpt-tools.git
ignore = dirty
[submodule "css/tools/apiclient"] [submodule "css/tools/apiclient"]
path = css/tools/apiclient path = css/tools/apiclient
url = https://github.com/w3c/csswg-apiclient.git url = https://github.com/w3c/csswg-apiclient.git
[submodule "css/tools/w3ctestlib"] [submodule "css/tools/w3ctestlib"]
path = css/tools/w3ctestlib path = css/tools/w3ctestlib
url = https://github.com/w3c/csswg-w3ctestlib.git url = https://github.com/w3c/csswg-w3ctestlib.git
[submodule "tools/html5lib/html5lib/tests/testdata"]
path = tools/html5lib/html5lib/tests/testdata
url = https://github.com/html5lib/html5lib-tests.git
[submodule "resources/webidl2/test/widlproc"]
path = resources/webidl2/test/widlproc
url = https://github.com/dontcallmedom/widlproc.git

32
tests/wpt/web-platform-tests/.travis.yml
View file

@ -1,6 +1,9 @@
dist: trusty dist: trusty
sudo: required sudo: required
language: python language: python
branches:
only:
- master
addons: addons:
hosts: hosts:
- web-platform.test - web-platform.test
@ -9,6 +12,8 @@ addons:
- www2.web-platform.test - www2.web-platform.test
- xn--n8j6ds53lwwkrqhv28a.web-platform.test - xn--n8j6ds53lwwkrqhv28a.web-platform.test
- xn--lve-6lad.web-platform.test - xn--lve-6lad.web-platform.test
jwt:
secure: N9lvgkqUPtFlz6Vpa6qTPFhymEsDCsbaCsT64/hj3vlHRxK94r5+ugVJ3zm99zC0q2j1ish8yJC7mN/W4wRfBE4sAwmdxrlowxF1DDGCkaLE9i/GWW92s0fBVGJmXLh8kwNkQ31hMOsaGfHIMpeLFS7Se741te7YqsHIzmBCdQs=
before_install: before_install:
- git submodule update --init --recursive - git submodule update --init --recursive
- export DISPLAY=:99.0 - export DISPLAY=:99.0
@ -17,7 +22,10 @@ install:
- pip install -U setuptools - pip install -U setuptools
- pip install -U requests - pip install -U requests
env: # required at the top-level for allow_failures to work below env: # required at the top-level for allow_failures to work below
global:
- SAUCE_USERNAME=w3c-ttwf
matrix: matrix:
fast_finish: true
include: include:
- os: linux - os: linux
python: "2.7" python: "2.7"
@ -48,10 +56,34 @@ matrix:
env: env:
- secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM=" - secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM="
- SCRIPT=ci_stability.sh PRODUCT=chrome:unstable - SCRIPT=ci_stability.sh PRODUCT=chrome:unstable
- os: linux
python: "2.7"
env:
- secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM="
- SCRIPT=ci_stability.sh PRODUCT=sauce:safari:10.0 PLATFORM='macOS 10.12'
- os: linux
python: "2.7"
env:
- secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM="
- SCRIPT=ci_stability.sh PRODUCT=sauce:MicrosoftEdge:14.14393 PLATFORM='Windows 10'
- python: 2.7
env: TOXENV=py27 HYPOTHESIS_PROFILE=ci SCRIPT=ci_unittest.sh
- python: 3.5
env: TOXENV=py35 HYPOTHESIS_PROFILE=ci SCRIPT=ci_unittest.sh
- python: 3.6
env: TOXENV=py36 HYPOTHESIS_PROFILE=ci SCRIPT=ci_unittest.sh
- python: pypy
env: TOXENV=pypy HYPOTHESIS_PROFILE=ci SCRIPT=ci_unittest.sh
exclude: exclude:
- env: # exclude empty env from the top-level above - env: # exclude empty env from the top-level above
allow_failures: allow_failures:
- env: SCRIPT=css/build-css-testsuites.sh - env: SCRIPT=css/build-css-testsuites.sh
- env:
- secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM="
- SCRIPT=ci_stability.sh PRODUCT=chrome:unstable
- env:
- secure: "YTSXPwI0DyCA1GhYrLT9KMEV6b7QQKuEeaQgeFDP38OTzJ1+cIj3CC4SRNqbnJ/6SJwPGcdqSxLuV8m4e5HFFnyCcQnJe6h8EMsTehZ7W3j/fP9UYrJqYqvGpe3Vj3xblO5pwBYmq7sg3jAmmuCgAgOW6VGf7cRMucrsmFeo7VM="
- SCRIPT=ci_stability.sh PRODUCT=sauce:MicrosoftEdge:14.14393 PLATFORM='Windows 10'
script: script:
- bash $SCRIPT - bash $SCRIPT
cache: cache:

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_1.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_1_ref.html> <link rel=match href=drawimage_html_image_1_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_10.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_10_ref.html> <link rel=match href=drawimage_html_image_10_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_11.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_11_ref.html> <link rel=match href=drawimage_html_image_11_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_12.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_12_ref.html> <link rel=match href=drawimage_html_image_12_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_2.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_2_ref.html> <link rel=match href=drawimage_html_image_2_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_3.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_3_ref.html> <link rel=match href=drawimage_html_image_3_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_4.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_4_ref.html> <link rel=match href=drawimage_html_image_4_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_5.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_5_ref.html> <link rel=match href=drawimage_html_image_5_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_6.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_6_ref.html> <link rel=match href=drawimage_html_image_6_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_7.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_7_ref.html> <link rel=match href=drawimage_html_image_7_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/drawing-images-to-the-canvas/drawimage_html_image_8.html
View file

@ -1,5 +1,4 @@
<!DOCTYPE html> <!DOCTYPE html>
<html>
<meta charset="utf-8"> <meta charset="utf-8">
<link rel=match href=drawimage_html_image_8_ref.html> <link rel=match href=drawimage_html_image_8_ref.html>
<style> <style>

1
tests/wpt/web-platform-tests/2dcontext/transformations/canvas_transformations_scale_001.htm
View file

@ -1,4 +1,5 @@
<!doctype HTML> <!doctype HTML>
<html> <html>
<head> <head>
<title>HTML5 Canvas Test: scale() transformation</title> <title>HTML5 Canvas Test: scale() transformation</title>

16
tests/wpt/web-platform-tests/DOM-parsing/todo/internalSubset.html
View file

@ -1,16 +0,0 @@
<!DOCTYPE html>
...
<script>
var p = new DOMParser(), s = new XMLSerializer();
var doc = p.parseFromString("<!DOCTYPE foo [ <!ELEMENT foo (#PCDATA)> ]><foo/>", "text/xml")
w(s.serializeToString(doc))
</script>
<table>
<caption>Results</caption>
<thead>
<tr><th>UA<th>Result
<tbody>
<tr><th>Gecko<td><code>&lt;!DOCTYPE foo [ &lt;!ELEMENT foo (#PCDATA)> ]>\n&lt;foo/></code>
<tr><th>WebKit<td><code>&lt;!DOCTYPE foo>&lt;foo/></code>
<tr><th>Presto<td><code>&lt;?xml version="1.0"?>&lt;!DOCTYPE foo>&lt;foo/></code>
</table>

4
tests/wpt/web-platform-tests/IndexedDB/idb_webworkers.htm
View file

@ -8,6 +8,7 @@
<script> <script>
var db, count = 0, var db, count = 0,
t = async_test(); t = async_test();
t.add_cleanup(function() { indexedDB.deleteDatabase('webworker101'); });
t.step(function() { t.step(function() {
var worker = new Worker("idbworker.js"); var worker = new Worker("idbworker.js");
@ -27,7 +28,4 @@
worker.postMessage(1); worker.postMessage(1);
}) })
</script> </script>
<div id="log"></div>

297
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance-continue-async.htm
View file

@ -7,180 +7,175 @@
<script> <script>
var db, open; function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() { objStore.add("data", 1);
open = indexedDB.open('testdb-' + new Date().getTime()); objStore.add("data2", 2);
open.onupgradeneeded = function(e) { }
db = e.target.result;
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("data", 1); indexeddb_test(
objStore.add("data2", 2); upgrade_func,
}; function(t, db) {
}, var count = 0;
{ explicit_done: true }); var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() { switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
cursor.advance(1)
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
cursor.advance(1)
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
async_test(document.title + " - advance").step(function(e) { default:
var count = 0; assert_unreached("Unexpected count: " + count)
var rq = db.transaction("test").objectStore("test").openCursor(); }
rq.onsuccess = this.step_func(function(e) { count++;
if (!e.target.result) { });
assert_equals(count, 2, 'count'); rq.onerror = t.unreached_func("unexpected error")
this.done(); },
return; document.title + " - advance"
} );
var cursor = e.target.result;
switch(count) { indexeddb_test(
case 0: upgrade_func,
assert_equals(cursor.value, "data") function(t, db) {
assert_equals(cursor.key, 1) var count = 0;
cursor.advance(1) var rq = db.transaction("test").objectStore("test").index("index").openCursor();
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1: rq.onsuccess = t.step_func(function(e) {
assert_equals(cursor.value, "data2") if (!e.target.result) {
assert_equals(cursor.key, 2) assert_equals(count, 2, 'count');
cursor.advance(1) t.done();
assert_equals(cursor.value, "data2") return;
assert_equals(cursor.key, 2) }
break var cursor = e.target.result;
default: switch(count) {
assert_unreached("Unexpected count: " + count) case 0:
} assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
cursor.continue("data2")
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
break
count++; case 1:
}); assert_equals(cursor.value, "data2")
rq.onerror = fail(this, "unexpected error") assert_equals(cursor.key, "data2")
}); assert_equals(cursor.primaryKey, 2)
cursor.continue()
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
default:
assert_unreached("Unexpected count: " + count)
}
async_test(document.title + " - continue").step(function(e) { count++;
var count = 0; });
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - continue"
);
rq.onsuccess = this.step_func(function(e) { indexeddb_test(
if (!e.target.result) { upgrade_func,
assert_equals(count, 2, 'count'); function(t, db) {
this.done(); var count = 0;
return; var rq = db.transaction("test").objectStore("test").index("index").openCursor();
}
var cursor = e.target.result;
switch(count) { rq.onsuccess = t.step_func(function(e) {
case 0: if (!e.target.result) {
assert_equals(cursor.value, "data") assert_equals(count, 2, 'count');
assert_equals(cursor.key, "data") t.done();
assert_equals(cursor.primaryKey, 1) return;
cursor.continue("data2") }
assert_equals(cursor.value, "data") var cursor = e.target.result;
assert_equals(cursor.key, "data") cursor.advance(1)
assert_equals(cursor.primaryKey, 1)
break
case 1: switch(count) {
assert_equals(cursor.value, "data2") case 0:
assert_equals(cursor.key, "data2") assert_equals(cursor.value, "data")
assert_equals(cursor.primaryKey, 2) assert_equals(cursor.key, "data")
cursor.continue() assert_equals(cursor.primaryKey, 1)
assert_equals(cursor.value, "data2") break
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
default: case 1:
assert_unreached("Unexpected count: " + count) assert_equals(cursor.value, "data2")
} assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
count++; default:
}); assert_unreached("Unexpected count: " + count)
rq.onerror = fail(this, "unexpected error") }
});
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - fresh advance still async"
);
async_test(document.title + " - fresh advance still async").step(function(e) { indexeddb_test(
var count = 0; upgrade_func,
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) { if (!e.target.result) {
assert_equals(count, 2, 'count'); assert_equals(count, 2, 'count');
this.done(); t.done();
return; return;
} }
var cursor = e.target.result; var cursor = e.target.result;
cursor.advance(1) cursor.continue()
switch(count) { switch(count) {
case 0: case 0:
assert_equals(cursor.value, "data") assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data") assert_equals(cursor.key, 1)
assert_equals(cursor.primaryKey, 1) break
break
case 1: case 1:
assert_equals(cursor.value, "data2") assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2") assert_equals(cursor.key, 2)
assert_equals(cursor.primaryKey, 2) break
break
default: default:
assert_unreached("Unexpected count: " + count) assert_unreached("Unexpected count: " + count)
} }
count++;
});
rq.onerror = fail(this, "unexpected error")
});
async_test(document.title + " - fresh continue still async").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
cursor.continue()
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
default:
assert_unreached("Unexpected count: " + count)
}
count++;
});
rq.onerror = fail(this, "unexpected error")
});
// Stop blocking the testing system from hereon
done();
}
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - fresh continue still async"
);
</script> </script>
<div id=log></div>

226
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance-invalid.htm
View file

@ -13,176 +13,180 @@
<script> <script>
var db, open; function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() { objStore.add("data", 1);
open = indexedDB.open('testdb-' + new Date().getTime()); objStore.add("data2", 2);
open.onupgradeneeded = function(e) { }
db = e.target.result;
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("data", 1); indexeddb_test(
objStore.add("data2", 2); upgrade_func,
}; function(t, db) {
}, var count = 0;
{ explicit_done: true }); var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() { cursor.advance(1);
async_test(document.title + " - attempt to call advance twice").step(function(e) { // Second try
var count = 0; assert_throws('InvalidStateError',
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
cursor.advance(1);
// Second try
assert_throws('InvalidStateError',
function() { cursor.advance(1); }, 'second advance'); function() { cursor.advance(1); }, 'second advance');
assert_throws('InvalidStateError', assert_throws('InvalidStateError',
function() { cursor.advance(3); }, 'third advance'); function() { cursor.advance(3); }, 'third advance');
count++; count++;
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - attempt to call advance twice"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - pass something other than number").step(function(e) { rq.onsuccess = t.step_func(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); var cursor = e.target.result;
rq.onsuccess = this.step_func(function(e) { assert_throws({ name: "TypeError" },
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
function() { cursor.advance(document); }); function() { cursor.advance(document); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance({}); }); function() { cursor.advance({}); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance([]); }); function() { cursor.advance([]); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(""); }); function() { cursor.advance(""); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance("1 2"); }); function() { cursor.advance("1 2"); });
this.done(); t.done();
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - pass something other than number"
);
async_test(document.title + " - pass null/undefined").step(function(e) { indexeddb_test(
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result; var cursor = e.target.result;
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(null); }); function() { cursor.advance(null); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(undefined); }); function() { cursor.advance(undefined); });
var myvar = null; var myvar = null;
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(myvar); }); function() { cursor.advance(myvar); });
this.done(); t.done();
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - pass null/undefined"
);
async_test(document.title + " - missing argument").step(function(e) { indexeddb_test(
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result; var cursor = e.target.result;
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(); }); function() { cursor.advance(); });
this.done(); t.done();
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - missing argument"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - pass negative numbers").step(function(e) { rq.onsuccess = t.step_func(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); var cursor = e.target.result;
rq.onsuccess = this.step_func(function(e) { assert_throws({ name: "TypeError" },
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
function() { cursor.advance(-1); }); function() { cursor.advance(-1); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(NaN); }); function() { cursor.advance(NaN); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(0); }); function() { cursor.advance(0); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(-0); }); function() { cursor.advance(-0); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(Infinity); }); function() { cursor.advance(Infinity); });
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(-Infinity); }); function() { cursor.advance(-Infinity); });
var myvar = -999999; var myvar = -999999;
assert_throws({ name: "TypeError" }, assert_throws({ name: "TypeError" },
function() { cursor.advance(myvar); }); function() { cursor.advance(myvar); });
this.done(); t.done();
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - pass negative numbers"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - got value not set on exception").step(function(e) { rq.onsuccess = t.step_func(function(e) {
var count = 0; var cursor = e.target.result;
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); if (!cursor)
{
assert_equals(count, 2, "count runs");
t.done();
return;
}
rq.onsuccess = this.step_func(function(e) { assert_throws({ name: "TypeError" },
var cursor = e.target.result;
if (!cursor)
{
assert_equals(count, 2, "count runs");
this.done();
return;
}
assert_throws({ name: "TypeError" },
function() { cursor.advance(0); }); function() { cursor.advance(0); });
cursor.advance(1); cursor.advance(1);
count++; count++;
}); });
rq.onerror = fail(this, "unexpected error") rq.onerror = t.unreached_func("unexpected error")
}); },
document.title + " - got value not set on exception"
);
// Stop blocking the testing system from hereon
done();
}
</script> </script>
<div id=log></div>

394
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance.htm
View file

@ -7,237 +7,241 @@
<script> <script>
var db, open; function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() { objStore.add("cupcake", 5);
open = indexedDB.open("testdb-" + new Date().getTime()); objStore.add("pancake", 3); // Yes, it is intended
open.onupgradeneeded = function(e) { objStore.add("pie", 1);
db = e.target.result; objStore.add("pie", 4);
var objStore = db.createObjectStore("test"); objStore.add("taco", 2);
objStore.createIndex("index", ""); }
objStore.add("cupcake", 5); indexeddb_test(
objStore.add("pancake", 3); // Yes, it is intended upgrade_func,
objStore.add("pie", 1); function(t, db) {
objStore.add("pie", 4); var count = 0;
objStore.add("taco", 2); var rq = db.transaction("test").objectStore("test").index("index").openCursor();
};
},
{ explicit_done: true });
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, "count");
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() { switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
async_test(document.title + " - advances").step(function(e) { case 1:
var count = 0; assert_equals(cursor.value, "pie");
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); assert_equals(cursor.primaryKey, 1);
break;
rq.onsuccess = this.step_func(function(e) { case 2:
if (!e.target.result) { assert_equals(cursor.value, "taco");
assert_equals(count, 3, "count"); assert_equals(cursor.primaryKey, 2);
this.done(); break;
return;
}
var cursor = e.target.result;
switch(count) { default:
case 0: assert_unreached("Unexpected count: " + count);
assert_equals(cursor.value, "cupcake"); }
assert_equals(cursor.primaryKey, 5);
break;
case 1: count++;
assert_equals(cursor.value, "pie"); cursor.advance(2);
assert_equals(cursor.primaryKey, 1); });
break; rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - advances"
);
case 2: indexeddb_test(
assert_equals(cursor.value, "taco"); upgrade_func,
assert_equals(cursor.primaryKey, 2); function(t, db) {
break; var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor(null, "prev");
default: rq.onsuccess = t.step_func(function(e) {
assert_unreached("Unexpected count: " + count); if (!e.target.result) {
} assert_equals(count, 3, "count");
t.done();
return;
}
var cursor = e.target.result;
count++; switch(count) {
cursor.advance(2); case 0:
}); assert_equals(cursor.value, "taco");
rq.onerror = fail(this, "unexpected error") assert_equals(cursor.primaryKey, 2);
}); break;
async_test(document.title + " - advances backwards").step(function(e) { case 1:
var count = 0; assert_equals(cursor.value, "pie");
var rq = db.transaction("test").objectStore("test").index("index").openCursor(null, "prev"); assert_equals(cursor.primaryKey, 1);
break;
rq.onsuccess = this.step_func(function(e) { case 2:
if (!e.target.result) { assert_equals(cursor.value, "cupcake");
assert_equals(count, 3, "count"); assert_equals(cursor.primaryKey, 5);
this.done(); break;
return;
}
var cursor = e.target.result;
switch(count) { default:
case 0: assert_unreached("Unexpected count: " + count);
assert_equals(cursor.value, "taco"); }
assert_equals(cursor.primaryKey, 2);
break;
case 1: count++;
assert_equals(cursor.value, "pie"); cursor.advance(2);
assert_equals(cursor.primaryKey, 1); });
break; rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - advances backwards"
);
case 2: indexeddb_test(
assert_equals(cursor.value, "cupcake"); upgrade_func,
assert_equals(cursor.primaryKey, 5); function(t, db) {
break; var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
default: rq.onsuccess = t.step_func(function(e) {
assert_unreached("Unexpected count: " + count); if (!e.target.result) {
} assert_equals(count, 1, "count");
t.done();
return;
}
var cursor = e.target.result;
count++; switch(count) {
cursor.advance(2); case 0:
}); assert_equals(cursor.value, "cupcake");
rq.onerror = fail(this, "unexpected error") assert_equals(cursor.primaryKey, 5);
}); break;
async_test(document.title + " - skip far forward").step(function(e) { default:
var count = 0; assert_unreached("Unexpected count: " + count);
var rq = db.transaction("test").objectStore("test").index("index") }
.openCursor();
rq.onsuccess = this.step_func(function(e) { count++;
if (!e.target.result) { cursor.advance(100000);
assert_equals(count, 1, "count"); });
this.done(); rq.onerror = t.unreached_func("unexpected error")
return; },
} document.title + " - skip far forward"
var cursor = e.target.result; );
switch(count) { indexeddb_test(
case 0: upgrade_func,
assert_equals(cursor.value, "cupcake"); function(t, db) {
assert_equals(cursor.primaryKey, 5); var count = 0;
break; var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
default: rq.onsuccess = t.step_func(function(e) {
assert_unreached("Unexpected count: " + count); if (!e.target.result) {
} assert_equals(count, 2, "count");
t.done();
return;
}
var cursor = e.target.result;
count++; switch(count) {
cursor.advance(100000); case 0:
}); assert_equals(cursor.value, "pancake");
rq.onerror = fail(this, "unexpected error") assert_equals(cursor.primaryKey, 3);
}); break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
async_test(document.title + " - within range").step(function(e) { default:
var count = 0; assert_unreached("Unexpected count: " + count);
var rq = db.transaction("test").objectStore("test").index("index") }
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
rq.onsuccess = this.step_func(function(e) { count++;
if (!e.target.result) { cursor.advance(2);
assert_equals(count, 2, "count"); });
this.done(); rq.onerror = t.unreached_func("unexpected error")
return; },
} document.title + " - within range"
var cursor = e.target.result; );
switch(count) { indexeddb_test(
case 0: upgrade_func,
assert_equals(cursor.value, "pancake"); function(t, db) {
assert_equals(cursor.primaryKey, 3); var count = 0;
break; var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
case 1: rq.onsuccess = t.step_func(function(e) {
assert_equals(cursor.value, "pie"); if (!e.target.result) {
assert_equals(cursor.primaryKey, 4); assert_equals(count, 1, "count");
break; t.done();
return;
}
var cursor = e.target.result;
default: switch(count) {
assert_unreached("Unexpected count: " + count); case 0:
} assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
break;
count++; default:
cursor.advance(2); assert_unreached("Unexpected count: " + count);
}); }
rq.onerror = fail(this, "unexpected error")
});
count++;
cursor.advance(1);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - within single key range"
);
async_test(document.title + " - within single key range").step(function(e) { indexeddb_test(
var count = 0; upgrade_func,
var rq = db.transaction("test").objectStore("test").index("index") function(t, db) {
.openCursor("pancake"); var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) { if (!e.target.result) {
assert_equals(count, 1, "count"); assert_equals(count, 2, "count");
this.done(); t.done();
return; return;
} }
var cursor = e.target.result; var cursor = e.target.result;
switch(count) { switch(count) {
case 0: case 0:
assert_equals(cursor.value, "pancake"); assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 3); assert_equals(cursor.primaryKey, 1);
break; break;
default: case 1:
assert_unreached("Unexpected count: " + count); assert_equals(cursor.value, "pie");
} assert_equals(cursor.primaryKey, 4);
break;
count++; default:
cursor.advance(1); assert_unreached("Unexpected count: " + count);
}); }
rq.onerror = fail(this, "unexpected error")
});
count++;
async_test(document.title + " - within single key range, with several results").step(function(e) { cursor.advance(1);
var count = 0; });
var rq = db.transaction("test").objectStore("test").index("index") rq.onerror = t.unreached_func("unexpected error")
.openCursor("pie"); },
document.title + " - within single key range, with several results"
rq.onsuccess = this.step_func(function(e) { );
if (!e.target.result) {
assert_equals(count, 2, "count");
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
cursor.advance(1);
});
rq.onerror = fail(this, "unexpected error")
});
// Stop blocking the testing system from hereon
done();
}
</script> </script>
<div id="log"></div>

404
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continue.htm
View file

@ -9,232 +9,240 @@
<script> <script>
var db, open; var store = [ { value: "cupcake", key: 5 },
var store = [ { value: "cupcake", key: 5 }, { value: "pancake", key: 3 },
{ value: "pancake", key: 3 }, { value: "pie", key: 1 },
{ value: "pie", key: 1 }, { value: "pie", key: 4 },
{ value: "pie", key: 4 }, { value: "taco", key: 2 } ];
{ value: "taco", key: 2 } ];
setup(function() { function upgrade_func(t, db, tx) {
open = indexedDB.open('testdb-' + new Date().getTime()); var db, open;
open.onupgradeneeded = function(e) {
var os, i;
db = e.target.result;
os = db.createObjectStore("test");
os.createIndex("index", "");
for (i = 0; i < store.length; i++) var os, i;
os.add(store[i].value, store[i].key); os = db.createObjectStore("test");
}; os.createIndex("index", "");
},
{ explicit_done: true }); for (i = 0; i < store.length; i++)
os.add(store[i].value, store[i].key);
}
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 5, 'count');
t.done();
return;
}
var cursor = e.target.result;
assert_equals(cursor.value, store[count].value);
assert_equals(cursor.primaryKey, store[count].key);
cursor.continue();
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - continues"
);
open.onsuccess = function() { indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, 'count');
t.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
cursor.continue("pie");
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue("taco");
break;
case 2:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
cursor.continue();
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - with given key"
);
async_test(document.title + " - continues").step(function(e) { indexeddb_test(
var count = 0; upgrade_func,
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) { if (!e.target.result) {
assert_equals(count, 5, 'count'); assert_equals(count, 1, 'count');
this.done(); t.done();
return; return;
} }
var cursor = e.target.result; var cursor = e.target.result;
assert_equals(cursor.value, store[count].value); switch(count) {
assert_equals(cursor.primaryKey, store[count].key); case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
cursor.continue(); default:
assert_unreached("Unexpected count: " + count);
}
count++; count++;
}); cursor.continue([]); // Arrays are always bigger than strings
rq.onerror = fail(this, "unexpected error")
}); });
rq.onerror = t.unreached_func("unexpected error2")
},
document.title + " - skip far forward"
);
async_test(document.title + " - with given key").step(function(e) { indexeddb_test(
var count = 0; upgrade_func,
var rq = db.transaction("test").objectStore("test").index("index").openCursor(); function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) { if (!e.target.result) {
assert_equals(count, 3, 'count'); assert_equals(count, 2, 'count');
this.done(); t.done();
return; return;
} }
var cursor = e.target.result; var cursor = e.target.result;
switch(count) { switch(count) {
case 0: case 0:
assert_equals(cursor.value, "cupcake"); assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 5); assert_equals(cursor.primaryKey, 3);
cursor.continue("pie"); cursor.continue("pie");
break; break;
case 1: case 1:
assert_equals(cursor.value, "pie"); assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1); assert_equals(cursor.primaryKey, 1);
cursor.continue("taco"); cursor.continue("zzz");
break; break;
case 2: default:
assert_equals(cursor.value, "taco"); assert_unreached("Unexpected count: " + count);
assert_equals(cursor.primaryKey, 2); }
cursor.continue();
break;
default: count++;
assert_unreached("Unexpected count: " + count); });
} rq.onerror = t.unreached_func("unexpected error1")
},
count++; document.title + " - within range"
}); );
rq.onerror = fail(this, "unexpected error")
});
async_test(document.title + " - skip far forward").step(function(e) { indexeddb_test(
var count = 0; upgrade_func,
var rq = db.transaction("test").objectStore("test").index("index") function(t, db) {
.openCursor(); var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
rq.onsuccess = this.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) { if (!e.target.result) {
assert_equals(count, 1, 'count'); assert_equals(count, 1, 'count');
this.done(); t.done();
return; return;
} }
var cursor = e.target.result; var cursor = e.target.result;
switch(count) { switch(count) {
case 0: case 0:
assert_equals(cursor.value, "cupcake"); assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 5); assert_equals(cursor.primaryKey, 3);
break; cursor.continue("pie");
break;
default: default:
assert_unreached("Unexpected count: " + count); assert_unreached("Unexpected count: " + count);
} }
count++; count++;
cursor.continue([]); // Arrays are always bigger than strings });
rq.onerror = t.unreached_func("unexpected error1")
},
document.title + " - within single key range"
);
}); indexeddb_test(
rq.onerror = fail(this, "unexpected error2") upgrade_func,
}); function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
async_test(document.title + " - within range").step(function(e) { switch(count) {
var count = 0; case 0:
var rq = db.transaction("test").objectStore("test").index("index") assert_equals(cursor.value, "pie");
.openCursor(IDBKeyRange.lowerBound("cupcake", true)); assert_equals(cursor.primaryKey, 1);
cursor.continue();
break;
rq.onsuccess = this.step_func(function(e) { case 1:
if (!e.target.result) { assert_equals(cursor.value, "pie");
assert_equals(count, 2, 'count'); assert_equals(cursor.primaryKey, 4);
this.done(); cursor.continue();
return; break;
}
var cursor = e.target.result;
switch(count) { default:
case 0: assert_unreached("Unexpected count: " + count);
assert_equals(cursor.value, "pancake"); }
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
case 1: count++;
assert_equals(cursor.value, "pie"); });
assert_equals(cursor.primaryKey, 1); rq.onerror = t.unreached_func("unexpected error1")
cursor.continue("zzz"); },
break; document.title + " - within single key range, with several results"
);
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
async_test(document.title + " - within single key range").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, 'count');
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
async_test(document.title + " - within single key range, with several results").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue();
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
cursor.continue();
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
// Stop blocking the testing system from hereon
done();
}
</script> </script>
<div id="log"></div>

6
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continuePrimaryKey-exception-order.htm
View file

@ -45,12 +45,12 @@ indexeddb_test(
store.deleteIndex("idx"); store.deleteIndex("idx");
}); });
txn.oncomplete = function() { txn.oncomplete = t.step_func(function() {
assert_throws("TransactionInactiveError", function() { assert_throws("TransactionInactiveError", function() {
cursor.continuePrimaryKey("A", 4); cursor.continuePrimaryKey("A", 4);
}, "transaction-state check should precede deletion check"); }, "transaction-state check should precede deletion check");
t.done(); t.done();
}; });
}, },
null, null,
"TransactionInactiveError v.s. InvalidStateError(deleted index)" "TransactionInactiveError v.s. InvalidStateError(deleted index)"
@ -378,5 +378,3 @@ indexeddb_test(
"DataError(keys are larger then current one) in 'prev' direction" "DataError(keys are larger then current one) in 'prev' direction"
); );
</script> </script>
<div id="log"></div>

8
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continuePrimaryKey-exceptions.htm
View file

@ -16,6 +16,10 @@ async_test(function(t) {
open.onupgradeneeded = t.step_func(function() { open.onupgradeneeded = t.step_func(function() {
var db = open.result; var db = open.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var store = db.createObjectStore('store'); var store = db.createObjectStore('store');
store.put('a', 1).onerror = t.unreached_func('put should not fail'); store.put('a', 1).onerror = t.unreached_func('put should not fail');
var request = store.openCursor(); var request = store.openCursor();
@ -60,6 +64,10 @@ async_test(function(t) {
open.onupgradeneeded = t.step_func(function() { open.onupgradeneeded = t.step_func(function() {
var db = open.result; var db = open.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var store = db.createObjectStore('store', {keyPath: 'pk'}); var store = db.createObjectStore('store', {keyPath: 'pk'});
var index = store.createIndex('index', 'ik', {multiEntry: true}); var index = store.createIndex('index', 'ik', {multiEntry: true});
store.put({pk: 'a', ik: [1,2,3]}).onerror = store.put({pk: 'a', ik: [1,2,3]}).onerror =

99
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-index-keyrange.htm
View file

@ -15,69 +15,46 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var records = [ 1337, "Alice", "Bob", "Bob", "Greg", "Åke", ["Anne"] ]; var records = [ 1337, "Alice", "Bob", "Bob", "Greg", "Åke", ["Anne"] ];
var directions = ["next", "prev", "nextunique", "prevunique"]; var cases = [
var tests = {}; {dir: 'next', expect: ['Alice:1', 'Bob:2', 'Bob:3', 'Greg:4']},
{dir: 'prev', expect: ['Greg:4', 'Bob:3', 'Bob:2', 'Alice:1']},
directions.forEach(function(dir) { {dir: 'nextunique', expect: ['Alice:1', 'Bob:2', 'Greg:4']},
tests[dir] = async_test(document.title + ' - ' + dir); {dir: 'prevunique', expect: ['Greg:4', 'Bob:2', 'Alice:1']}
}); ];
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
objStore.createIndex("idx", "name");
for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
// The tests cases.forEach(function(testcase) {
testdir('next', ['Alice:1', 'Bob:2', 'Bob:3', 'Greg:4']); var dir = testcase.dir;
testdir('prev', ['Greg:4', 'Bob:3', 'Bob:2', 'Alice:1']); var expect = testcase.expect;
testdir('nextunique', ['Alice:1', 'Bob:2', 'Greg:4']); indexeddb_test(
testdir('prevunique', ['Greg:4', 'Bob:2', 'Alice:1']); function(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("idx", "name");
for (var i = 0; i < records.length; i++)
// Test function objStore.add({ name: records[i] }, i);
function testdir(dir, expect) { },
var count = 0; function(t, db) {
var t = tests[dir]; var count = 0;
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir); var rq = db.transaction("test").objectStore("test").index("idx").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) { rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result; var cursor = e.target.result;
if (!cursor) { if (!cursor) {
assert_equals(count, expect.length, "cursor runs"); assert_equals(count, expect.length, "cursor runs");
t.done(); t.done();
}
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
} }
}; assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
// Fail handling cursor.continue();
function fail_helper(name) { });
return function() { rq.onerror = t.step_func(function(e) {
directions.forEach(function(dir) { e.preventDefault();
tests[dir].step(function() { assert_unreached(name); }); e.stopPropagation();
}); assert_unreached("rq.onerror - " + e.message);
}; });
} },
open_rq.onblocked = fail_helper('open_rq.onblocked'); document.title + ' - ' + dir
open_rq.onerror = fail_helper('open_rq.onerror'); )
});
</script> </script>
<div id=log> </div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-index.htm
View file

@ -13,69 +13,45 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var records = [ "Alice", "Bob", "Bob", "Greg" ]; var records = [ "Alice", "Bob", "Bob", "Greg" ];
var directions = ["next", "prev", "nextunique", "prevunique"]; var cases = [
var tests = {}; {dir: 'next', expect: ['Alice:0', 'Bob:1', 'Bob:2', 'Greg:3']},
{dir: 'prev', expect: ['Greg:3', 'Bob:2', 'Bob:1', 'Alice:0']},
{dir: 'nextunique', expect: ['Alice:0', 'Bob:1', 'Greg:3']},
{dir: 'prevunique', expect: ['Greg:3', 'Bob:1', 'Alice:0']},
];
directions.forEach(function(dir) { cases.forEach(function(testcase) {
tests[dir] = async_test(document.title + ' - ' + dir); var dir = testcase.dir;
}); var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("idx", "name");
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random()); for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
open_rq.onupgradeneeded = function(e) { },
var objStore = e.target.result.createObjectStore("test"); function(t, db) {
objStore.createIndex("idx", "name"); var count = 0;
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(undefined, dir);
for (var i = 0; i < records.length; i++) rq.onsuccess = t.step_func(function(e) {
objStore.add({ name: records[i] }, i); var cursor = e.target.result;
}; if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
open_rq.onsuccess = function(e) { t.done();
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
// The tests
testdir('next', ['Alice:0', 'Bob:1', 'Bob:2', 'Greg:3']);
testdir('prev', ['Greg:3', 'Bob:2', 'Bob:1', 'Alice:0']);
testdir('nextunique', ['Alice:0', 'Bob:1', 'Greg:3']);
testdir('prevunique', ['Greg:3', 'Bob:1', 'Alice:0']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
} }
}; assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
// Fail handling cursor.continue();
function fail_helper(name) { });
return function() { rq.onerror = t.step_func(function(e) {
directions.forEach(function(dir) { e.preventDefault();
tests[dir].step(function() { assert_unreached(name); }); e.stopPropagation();
}); assert_unreached("rq.onerror - " + e.message);
}; });
} },
open_rq.onblocked = fail_helper('open_rq.onblocked'); document.title + ' - ' + dir
open_rq.onerror = fail_helper('open_rq.onerror'); );
});
</script> </script>
<div id=log> </div>

98
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-objectstore-keyrange.htm
View file

@ -11,68 +11,44 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var records = [ 1337, "Alice", "Bob", "Greg", "Åke", ["Anne"] ]; var records = [ 1337, "Alice", "Bob", "Greg", "Åke", ["Anne"] ];
var directions = ["next", "prev", "nextunique", "prevunique"]; var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {}; var cases = [
{dir: 'next', expect: ['Alice', 'Bob', 'Greg']},
directions.forEach(function(dir) { {dir: 'prev', expect: ['Greg', 'Bob', 'Alice']},
tests[dir] = async_test(document.title + ' - ' + dir); {dir: 'nextunique', expect: ['Alice', 'Bob', 'Greg']},
}); {dir: 'prevunique', expect: ['Greg', 'Bob', 'Alice']},
];
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
cases.forEach(function(testcase) {
var dir = testcase.dir;
var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
for (var i = 0; i < records.length; i++) for (var i = 0; i < records.length; i++)
objStore.add(records[i], records[i]); objStore.add(records[i], records[i]);
}; },
function(t, db) {
open_rq.onsuccess = function(e) { var count = 0;
var db = e.target.result; var rq = db.transaction("test").objectStore("test").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
db.onerror = fail_helper("db.onerror"); rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
// The tests assert_equals(count, expect.length, "cursor runs");
testdir('next', ['Alice', 'Bob', 'Greg']); t.done();
testdir('prev', ['Greg', 'Bob', 'Alice']);
testdir('nextunique', ['Alice', 'Bob', 'Greg']);
testdir('prevunique', ['Greg', 'Bob', 'Alice']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
} }
}; assert_equals(cursor.value, expect[count], "cursor.value");
count++;
// Fail handling cursor.continue();
function fail_helper(name) { });
return function() { rq.onerror = t.step_func(function(e) {
directions.forEach(function(dir) { e.preventDefault();
tests[dir].step(function() { assert_unreached(name); }); e.stopPropagation();
}); assert_unreached("rq.onerror - " + e.message);
}; });
} },
open_rq.onblocked = fail_helper('open_rq.onblocked'); document.title + ' - ' + dir
open_rq.onerror = fail_helper('open_rq.onerror'); );
});
</script> </script>
<div id=log> </div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-objectstore.htm
View file

@ -13,68 +13,44 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var records = [ "Alice", "Bob", "Greg" ]; var records = [ "Alice", "Bob", "Greg" ];
var directions = ["next", "prev", "nextunique", "prevunique"]; var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {}; var cases = [
{dir: 'next', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prev', expect: ['Greg', 'Bob', 'Alice']},
{dir: 'nextunique', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prevunique', expect: ['Greg', 'Bob', 'Alice']},
];
directions.forEach(function(dir) { cases.forEach(function(testcase) {
tests[dir] = async_test(document.title + ' - ' + dir); var dir = testcase.dir;
}); var expect = testcase.expect;
indexeddb_test(
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random()); function(t, db, tx) {
var objStore = db.createObjectStore("test");
open_rq.onupgradeneeded = function(e) { for (var i = 0; i < records.length; i++)
var objStore = e.target.result.createObjectStore("test"); objStore.add(records[i], records[i]);
},
for (var i = 0; i < records.length; i++) function(t, db) {
objStore.add(records[i], records[i]); var count = 0;
}; var rq = db.transaction("test").objectStore("test").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
open_rq.onsuccess = function(e) { var cursor = e.target.result;
var db = e.target.result; if (!cursor) {
db.onerror = fail_helper("db.onerror"); assert_equals(count, expect.length, "cursor runs");
t.done();
// The tests
testdir('next', ['Alice', 'Bob', 'Greg']);
testdir('prev', ['Greg', 'Bob', 'Alice']);
testdir('nextunique', ['Alice', 'Bob', 'Greg']);
testdir('prevunique', ['Greg', 'Bob', 'Alice']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
} }
}; assert_equals(cursor.value, expect[count], "cursor.value");
count++;
// Fail handling cursor.continue();
function fail_helper(name) { });
return function() { rq.onerror = t.step_func(function(e) {
directions.forEach(function(dir) { e.preventDefault();
tests[dir].step(function() { assert_unreached(name); }); e.stopPropagation();
}); assert_unreached("rq.onerror - " + e.message);
}; });
} },
open_rq.onblocked = fail_helper('open_rq.onblocked'); document.title + ' - ' + dir
open_rq.onerror = fail_helper('open_rq.onerror'); );
});
</script> </script>
<div id=log> </div>

7
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction.htm
View file

@ -17,6 +17,11 @@
open_rq.onupgradeneeded = function(e) { open_rq.onupgradeneeded = function(e) {
db = e.target.result; db = e.target.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var objStore = db.createObjectStore("test"); var objStore = db.createObjectStore("test");
objStore.add("data", "key"); objStore.add("data", "key");
@ -69,5 +74,3 @@
cursor_direction("prevunique", "prevunique"); cursor_direction("prevunique", "prevunique");
</script> </script>
<div id="log"></div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-source.htm
View file

@ -6,63 +6,61 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
setup({ explicit_done: true }); function cursor_source_test(test_name, name, stringified_object, cursor_rq_func) {
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("my_objectstore");
objStore.createIndex("my_index", "");
var db; objStore.add("data", 1);
var open_rq = indexedDB.open('testdb-' + new Date().getTime()); objStore.add("data2", 2);
open_rq.onupgradeneeded = function(e) { },
db = e.target.result; function(t, db) {
var objStore = db.createObjectStore("my_objectstore"); var cursor_rq = cursor_rq_func(db);
objStore.createIndex("my_index", "");
objStore.add("data", 1); cursor_rq.onsuccess = t.step_func(function(e) {
objStore.add("data2", 2); if (!e.target.result) {
}; return;
}
var cursor = e.target.result;
assert_readonly(cursor, 'source');
function cursor_source(name, stringified_object, cursor_rq) { // Direct try
var cursor; assert_true(cursor.source instanceof Object, "source isobject");
assert_equals(cursor.source + "", stringified_object, "source");
assert_equals(cursor.source.name, name, "name");
cursor_rq.onsuccess = this.step_func(function(e) { cursor.continue();
if (!e.target.result) { });
return;
}
cursor = e.target.result;
assert_readonly(cursor, 'source');
// Direct try cursor_rq.transaction.oncomplete = t.step_func(function(e) {
assert_true(cursor.source instanceof Object, "source isobject"); t.done();
assert_equals(cursor.source + "", stringified_object, "source"); });
assert_equals(cursor.source.name, name, "name");
cursor.continue(); cursor_rq.transaction.onerror = t.step_func(function(e) {
}); assert_unreached("Transaction got error. " + (e.target.error ? e.target.error.name : "unknown"));
});
},
test_name
);
}
cursor_rq.transaction.oncomplete = this.step_func(function(e) { cursor_source_test(
this.done(); document.title + ' - IDBObjectStore',
}); "my_objectstore",
"[object IDBObjectStore]",
cursor_rq.transaction.onerror = this.step_func(function(e) { function(db) { return db.transaction("my_objectstore")
assert_unreached("Transaction got error. " + (e.target.error ? e.target.error.name : "unknown")); .objectStore("my_objectstore")
}); .openCursor(); }
} );
open_rq.onsuccess = function() {
async_test(document.title + ' - IDBObjectStore').step(function() {
cursor_source.call(this, "my_objectstore", "[object IDBObjectStore]", db.transaction("my_objectstore")
.objectStore("my_objectstore")
.openCursor());
});
async_test(document.title + ' - IDBIndex').step(function() {
cursor_source.call(this, "my_index", "[object IDBIndex]", db.transaction("my_objectstore")
.objectStore("my_objectstore")
.index("my_index")
.openCursor());
});
done();
};
cursor_source_test(
document.title + ' - IDBIndex',
"my_index",
"[object IDBIndex]",
function(db) { return db.transaction("my_objectstore")
.objectStore("my_objectstore")
.index("my_index")
.openCursor(); }
);
</script> </script>
<div id="log"></div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating.htm
View file

@ -13,6 +13,7 @@
var open_rq = createdb(t); var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) { open_rq.onupgradeneeded = function(e) {
db = e.target.result; db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", { keyPath: "key" }); var objStore = db.createObjectStore("test", { keyPath: "key" });
for (var i = 0; i < 500; i++) for (var i = 0; i < 500; i++)
@ -106,5 +107,3 @@
}); });
}; };
</script> </script>
<div id="log"> </div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating_objectstore.htm
View file

@ -18,6 +18,7 @@
var open_rq = createdb(t); var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) { open_rq.onupgradeneeded = function(e) {
db = e.target.result; db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", {keyPath:"pKey"}); var objStore = db.createObjectStore("test", {keyPath:"pKey"});
for (var i = 0; i < records.length; i++) for (var i = 0; i < records.length; i++)
@ -47,5 +48,3 @@
}); });
}; };
</script> </script>
<div id="log"> </div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating_objectstore2.htm
View file

@ -18,6 +18,7 @@
var open_rq = createdb(t); var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) { open_rq.onupgradeneeded = function(e) {
db = e.target.result; db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", {keyPath:"pKey"}); var objStore = db.createObjectStore("test", {keyPath:"pKey"});
for (var i = 0; i < records.length; i++) for (var i = 0; i < records.length; i++)
@ -47,5 +48,3 @@
}); });
}; };
</script> </script>
<div id="log"> </div>

1
tests/wpt/web-platform-tests/IndexedDB/idbdatabase_close.htm
View file

@ -33,6 +33,7 @@ open_rq.onsuccess = function(e) {
assert_equals(blocked_fired, 1, 'block event fired #') assert_equals(blocked_fired, 1, 'block event fired #')
assert_equals(upgradeneeded_fired, 2, 'second upgradeneeded event fired #') assert_equals(upgradeneeded_fired, 2, 'second upgradeneeded event fired #')
rq.result.close();
t.done(); t.done();
}); });
rq.onerror = fail(t, 'Unexpected database deletion error'); rq.onerror = fail(t, 'Unexpected database deletion error');

28
tests/wpt/web-platform-tests/IndexedDB/idbfactory-deleteDatabase-request-success.html Normal file
View file

@ -0,0 +1,28 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory deleteDatabase(): request properties on success</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-deleteDatabase">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
async_test(t => {
const dbname = document.location + '-' + t.name;
const rq = indexedDB.deleteDatabase(dbname);
rq.onerror = t.unreached_func('deleteDatabase should succeed');
rq.onsuccess = t.step_func(() => {
assert_equals(
rq.readyState, 'done',
'request done flag should be set on success');
assert_equals(
rq.result, undefined,
'request result should still be set to undefined on success');
assert_equals(
rq.error, null,
'request error should be null on success');
t.done();
});
}, 'Properties of IDBOpenDBRequest during IDBFactory deleteDatabase()');
</script>

66
tests/wpt/web-platform-tests/IndexedDB/idbfactory-open-request-error.html Normal file
View file

@ -0,0 +1,66 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory open(): request properties on error</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-open">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
let saw_abort = false;
indexeddb_test(
(t, db, tx, rq) => {
const store = db.createObjectStore('store');
store.put({name: 'a'}, 1);
store.put({name: 'a'}, 2);
store.createIndex('index', 'name', {unique: true});
assert_equals(
rq.readyState, 'done',
'request done flag should be set during upgradeneeded');
assert_equals(
rq.result, db,
'request result should be set (to connection) during upgradeneeded');
assert_equals(
rq.error, null,
'request result should be null during upgradeneeded');
tx.oncomplete = t.unreached_func('transaction should abort');
tx.onabort = t.step_func(() => {
saw_abort = true;
assert_equals(
rq.readyState, 'done',
'request done flag should still be set during abort');
// Chrome is flaky here. See: https://crbug.com/723846
/*
assert_equals(
rq.result, db,
'request result should still be set (to connection) during abort');
assert_equals(
rq.error, null,
'request result should still be null during abort');
*/
});
rq.onerror = t.step_func(() => {
assert_true(saw_abort, 'abort event should fire before error');
assert_equals(
rq.readyState, 'done',
'request done flag should be set on error');
assert_equals(
rq.result, undefined,
'request result should be undefined on error');
assert_equals(
rq.error.name, 'AbortError',
'request error should be AbortError on error');
t.done();
});
},
(t, db) => {},
'Properties of IDBOpenDBRequest during failed IDBFactory open()',
{upgrade_will_abort: true});
</script>

54
tests/wpt/web-platform-tests/IndexedDB/idbfactory-open-request-success.html Normal file
View file

@ -0,0 +1,54 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory open(): request properties on success</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-open">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
let saw_complete = false;
indexeddb_test(
(t, db, tx, rq) => {
assert_equals(
rq.readyState, 'done',
'request done flag should be set during upgradeneeded');
assert_equals(
rq.result, db,
'request result should be set (to connection) during upgradeneeded');
assert_equals(
rq.error, null,
'request result should be null during upgradeneeded');
tx.onabort = t.unreached_func('transaction should complete');
tx.oncomplete = t.step_func(() => {
saw_complete = true;
assert_equals(
rq.readyState, 'done',
'request done flag should still be set during complete');
assert_equals(
rq.result, db,
'request result should still be set (to connection) during complete');
assert_equals(
rq.error, null,
'request result should still be null during complete');
});
},
(t, db, rq) => {
assert_true(saw_complete, 'complete event should fire before success');
assert_equals(
rq.readyState, 'done',
'request done flag should be set on success');
assert_equals(
rq.result, db,
'request result should still be set (to connection) on success');
assert_equals(
rq.error, null,
'request error should be null on success');
t.done();
},
'Properties of IDBOpenDBRequest during successful IDBFactory open()');
</script>

2
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open10.htm
View file

@ -81,6 +81,8 @@
}); });
idx.getKey("Sicking").onsuccess = this.step_func(function(e) { idx.getKey("Sicking").onsuccess = this.step_func(function(e) {
assert_equals(e.target.result, undefined, "getKey(Sicking)"); assert_equals(e.target.result, undefined, "getKey(Sicking)");
db3.close();
this.done(); this.done();
}); });
}); });

2
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open11.htm
View file

@ -51,6 +51,8 @@
count_done++; count_done++;
assert_equals(count_done, 3, "count_done"); assert_equals(count_done, 3, "count_done");
db2.close();
this.done(); this.done();
}); });
}); });

1
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open3.htm
View file

@ -17,6 +17,7 @@
var open_rq2 = window.indexedDB.open(db.name); var open_rq2 = window.indexedDB.open(db.name);
open_rq2.onsuccess = this.step_func(function(e) { open_rq2.onsuccess = this.step_func(function(e) {
assert_equals(e.target.result.version, 13, "db.version") assert_equals(e.target.result.version, 13, "db.version")
e.target.result.close();
this.done(); this.done();
}); });
open_rq2.onupgradeneeded = fail(this, 'Unexpected upgradeneeded') open_rq2.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

4
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open6.htm
View file

@ -8,13 +8,14 @@
<script> <script>
var open_rq = createdb(async_test(), undefined, 13); var open_rq = createdb(async_test(), undefined, 13);
var did_upgrade = false; var did_upgrade = false;
var open_rq2;
open_rq.onupgradeneeded = function() {}; open_rq.onupgradeneeded = function() {};
open_rq.onsuccess = function(e) { open_rq.onsuccess = function(e) {
var db = e.target.result; var db = e.target.result;
db.close(); db.close();
var open_rq2 = window.indexedDB.open(db.name, 14); open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2.onupgradeneeded = function() {}; open_rq2.onupgradeneeded = function() {};
open_rq2.onsuccess = this.step_func(open_previous_db); open_rq2.onsuccess = this.step_func(open_previous_db);
open_rq2.onerror = fail(this, 'Unexpected error') open_rq2.onerror = fail(this, 'Unexpected error')
@ -24,6 +25,7 @@
var open_rq3 = window.indexedDB.open(e.target.result.name, 13); var open_rq3 = window.indexedDB.open(e.target.result.name, 13);
open_rq3.onerror = this.step_func(function(e) { open_rq3.onerror = this.step_func(function(e) {
assert_equals(e.target.error.name, 'VersionError', 'e.target.error.name') assert_equals(e.target.error.name, 'VersionError', 'e.target.error.name')
open_rq2.result.close();
this.done(); this.done();
}); });
open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded') open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

5
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open7.htm
View file

@ -8,13 +8,14 @@
<script> <script>
var open_rq = createdb(async_test(), undefined, 13); var open_rq = createdb(async_test(), undefined, 13);
var did_upgrade = false; var did_upgrade = false;
var open_rq2;
open_rq.onupgradeneeded = function() {}; open_rq.onupgradeneeded = function() {};
open_rq.onsuccess = function(e) { open_rq.onsuccess = function(e) {
var db = e.target.result; var db = e.target.result;
db.close(); db.close();
var open_rq2 = window.indexedDB.open(db.name, 14); open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2.onupgradeneeded = function() { open_rq2.onupgradeneeded = function() {
did_upgrade = true; did_upgrade = true;
}; };
@ -26,6 +27,8 @@
var open_rq3 = window.indexedDB.open(e.target.result.name); var open_rq3 = window.indexedDB.open(e.target.result.name);
open_rq3.onsuccess = this.step_func(function(e) { open_rq3.onsuccess = this.step_func(function(e) {
assert_equals(e.target.result.version, 14, "db.version") assert_equals(e.target.result.version, 14, "db.version")
open_rq2.result.close();
open_rq3.result.close();
this.done(); this.done();
}); });
open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded') open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

58
tests/wpt/web-platform-tests/IndexedDB/idbindex_getAll.html
View file

@ -2,26 +2,14 @@
<title>IndexedDB: Test IDBIndex.getAll.</title> <title>IndexedDB: Test IDBIndex.getAll.</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split(''); var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
var ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''); var ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
function doSetup(dbName, dbVersion, onsuccess) { function getall_test(func, name) {
var delete_request = indexedDB.deleteDatabase(dbName); indexeddb_test(
delete_request.onerror = function() { function(t, connection, tx) {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
var store = connection.createObjectStore('generated', var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'}); {autoIncrement: true, keyPath: 'id'});
var index = store.createIndex('test_idx', 'upper'); var index = store.createIndex('test_idx', 'upper');
@ -61,8 +49,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
store = connection.createObjectStore('empty', null); store = connection.createObjectStore('empty', null);
index = store.createIndex('test_idx', 'upper'); index = store.createIndex('test_idx', 'upper');
}; },
}; func,
name
);
} }
function createGetAllRequest(t, storeName, connection, range, maxCount) { function createGetAllRequest(t, storeName, connection, range, maxCount) {
@ -74,9 +64,7 @@ function createGetAllRequest(t, storeName, connection, range, maxCount) {
return req; return req;
} }
doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) { getall_test(function(t, connection) {
var connection = evt.target.result;
async_test(function(t) {
var req = createGetAllRequest(t, 'out-of-line', connection, 'C'); var req = createGetAllRequest(t, 'out-of-line', connection, 'C');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result; var data = evt.target.result;
@ -87,7 +75,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Single item get'); }, 'Single item get');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'empty', connection); var req = createGetAllRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [], assert_array_equals(evt.target.result, [],
@ -96,7 +84,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Empty object store'); }, 'Empty object store');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection); var req = createGetAllRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result; var data = evt.target.result;
@ -107,7 +95,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get all keys'); }, 'Get all keys');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined, var req = createGetAllRequest(t, 'out-of-line', connection, undefined,
10); 10);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -119,7 +107,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'maxCount=10'); }, 'maxCount=10');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M')); IDBKeyRange.bound('G', 'M'));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -130,7 +118,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get bound range'); }, 'Get bound range');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'), 3); IDBKeyRange.bound('G', 'M'), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -142,7 +130,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get bound range with maxCount'); }, 'Get bound range with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', false, true)); IDBKeyRange.bound('G', 'K', false, true));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -154,7 +142,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get upper excluded'); }, 'Get upper excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', true, false)); IDBKeyRange.bound('G', 'K', true, false));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -166,7 +154,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get lower excluded'); }, 'Get lower excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated', var req = createGetAllRequest(t, 'generated',
connection, IDBKeyRange.bound(4, 15), 3); connection, IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -177,7 +165,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Get bound range (generated) with maxCount'); }, 'Get bound range (generated) with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', var req = createGetAllRequest(t, 'out-of-line',
connection, "Doesn't exist"); connection, "Doesn't exist");
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -188,7 +176,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Non existent key'); }, 'Non existent key');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
undefined, 0); undefined, 0);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -200,7 +188,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'maxCount=0'); }, 'maxCount=0');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line-not-unique', connection, var req = createGetAllRequest(t, 'out-of-line-not-unique', connection,
'first'); 'first');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -212,7 +200,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Retrieve multiEntry key'); }, 'Retrieve multiEntry key');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line-multi', connection, var req = createGetAllRequest(t, 'out-of-line-multi', connection,
'vowel'); 'vowel');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -225,8 +213,4 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
}); });
}, 'Retrieve one key multiple values'); }, 'Retrieve one key multiple values');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script> </script>

57
tests/wpt/web-platform-tests/IndexedDB/idbindex_getAllKeys.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBIndex.getAllKeys.</title> <title>IndexedDB: Test IDBIndex.getAllKeys.</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split(''); var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) { function getall_test(func, name) {
var delete_request = indexedDB.deleteDatabase(dbName); indexeddb_test(
delete_request.onerror = function() { function(t, connection, tx) {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
var store = connection.createObjectStore('generated', var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'}); {autoIncrement: true, keyPath: 'id'});
var index = store.createIndex('test_idx', 'upper'); var index = store.createIndex('test_idx', 'upper');
@ -51,8 +40,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
store = connection.createObjectStore('empty', null); store = connection.createObjectStore('empty', null);
index = store.createIndex('test_idx', 'upper'); index = store.createIndex('test_idx', 'upper');
}; },
}; func,
name
);
} }
function createGetAllKeysRequest(t, storeName, connection, range, maxCount) { function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
@ -64,9 +55,7 @@ function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
return req; return req;
} }
doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) { getall_test(function(t, connection) {
var connection = evt.target.result;
async_test(function(t) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'C'); var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'C');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result; var data = evt.target.result;
@ -75,7 +64,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Single item get'); }, 'Single item get');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'empty', connection); var req = createGetAllKeysRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [], assert_array_equals(evt.target.result, [],
@ -84,7 +73,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Empty object store'); }, 'Empty object store');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection); var req = createGetAllKeysRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, alphabet, assert_array_equals(evt.target.result, alphabet,
@ -93,7 +82,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get all keys'); }, 'Get all keys');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection); var req = createGetAllKeysRequest(t, 'generated', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, assert_array_equals(evt.target.result,
@ -104,7 +93,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get all generated keys'); }, 'Get all generated keys');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined, var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
10); 10);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -115,7 +104,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'maxCount=10'); }, 'maxCount=10');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M')); IDBKeyRange.bound('G', 'M'));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -126,7 +115,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range'); }, 'Get bound range');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'), 3); IDBKeyRange.bound('G', 'M'), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -137,7 +126,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range with maxCount'); }, 'Get bound range with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', false, true)); IDBKeyRange.bound('G', 'K', false, true));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -148,7 +137,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get upper excluded'); }, 'Get upper excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', true, false)); IDBKeyRange.bound('G', 'K', true, false));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -159,7 +148,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get lower excluded'); }, 'Get lower excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', var req = createGetAllKeysRequest(t, 'generated',
connection, IDBKeyRange.bound(4, 15), 3); connection, IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -169,7 +158,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range (generated) with maxCount'); }, 'Get bound range (generated) with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', var req = createGetAllKeysRequest(t, 'out-of-line',
connection, "Doesn't exist"); connection, "Doesn't exist");
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -180,7 +169,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'Non existent key'); }, 'Non existent key');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
undefined, 0); undefined, 0);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -190,7 +179,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
}); });
}, 'maxCount=0'); }, 'maxCount=0');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line-multi', connection, var req = createGetAllKeysRequest(t, 'out-of-line-multi', connection,
'vowel'); 'vowel');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -200,8 +189,4 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
req.onerror = t.unreached_func('getAllKeys request should succeed'); req.onerror = t.unreached_func('getAllKeys request should succeed');
}, 'Retrieve multiEntry keys'); }, 'Retrieve multiEntry keys');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script> </script>

1
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_deleteIndex.htm
View file

@ -35,6 +35,7 @@
assert_throws('NotFoundError', assert_throws('NotFoundError',
function() { index = objStore.index("index") }); function() { index = objStore.index("index") });
assert_equals(index, undefined); assert_equals(index, undefined);
db.close();
t.done(); t.done();
} }
} }

55
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getAll.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBObjectStore.getAll.</title> <title>IndexedDB: Test IDBObjectStore.getAll.</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split(''); var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) { function getall_test(func, name) {
var delete_request = indexedDB.deleteDatabase(dbName); indexeddb_test(
delete_request.onerror = function() { function(t, connection, tx) {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
var store = connection.createObjectStore('generated', var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'}); {autoIncrement: true, keyPath: 'id'});
alphabet.forEach(function(letter) { alphabet.forEach(function(letter) {
@ -33,8 +22,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
}); });
store = connection.createObjectStore('empty', null); store = connection.createObjectStore('empty', null);
}; },
}; func,
name
);
} }
function createGetAllRequest(t, storeName, connection, range, maxCount) { function createGetAllRequest(t, storeName, connection, range, maxCount) {
@ -45,9 +36,7 @@ function createGetAllRequest(t, storeName, connection, range, maxCount) {
return req; return req;
} }
doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) { getall_test(function(t, connection) {
var connection = evt.target.result;
async_test(function(t) {
var req = createGetAllRequest(t, 'out-of-line', connection, 'c'); var req = createGetAllRequest(t, 'out-of-line', connection, 'c');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, ['value-c']); assert_array_equals(evt.target.result, ['value-c']);
@ -55,7 +44,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Single item get'); }, 'Single item get');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated', connection, 3); var req = createGetAllRequest(t, 'generated', connection, 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result; var data = evt.target.result;
@ -67,7 +56,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Single item get (generated key)'); }, 'Single item get (generated key)');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'empty', connection); var req = createGetAllRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [], assert_array_equals(evt.target.result, [],
@ -76,7 +65,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'getAll on empty object store'); }, 'getAll on empty object store');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection); var req = createGetAllRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, assert_array_equals(evt.target.result,
@ -85,7 +74,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get all values'); }, 'Get all values');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined, var req = createGetAllRequest(t, 'out-of-line', connection, undefined,
10); 10);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -95,7 +84,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Test maxCount'); }, 'Test maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm')); IDBKeyRange.bound('g', 'm'));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -105,7 +94,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get bound range'); }, 'Get bound range');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'), 3); IDBKeyRange.bound('g', 'm'), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -115,7 +104,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get bound range with maxCount'); }, 'Get bound range with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', false, true)); IDBKeyRange.bound('g', 'k', false, true));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -125,7 +114,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get upper excluded'); }, 'Get upper excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', true, false)); IDBKeyRange.bound('g', 'k', true, false));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -135,7 +124,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get lower excluded'); }, 'Get lower excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated', connection, var req = createGetAllRequest(t, 'generated', connection,
IDBKeyRange.bound(4, 15), 3); IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -147,7 +136,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'Get bound range (generated) with maxCount'); }, 'Get bound range (generated) with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, var req = createGetAllRequest(t, 'out-of-line', connection,
"Doesn't exist"); "Doesn't exist");
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -158,7 +147,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
req.onerror = t.unreached_func('getAll request should succeed'); req.onerror = t.unreached_func('getAll request should succeed');
}, 'Non existent key'); }, 'Non existent key');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined, 0); var req = createGetAllRequest(t, 'out-of-line', connection, undefined, 0);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, assert_array_equals(evt.target.result,
@ -167,8 +156,4 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
}); });
}, 'zero maxCount'); }, 'zero maxCount');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script> </script>

55
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getAllKeys.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBObjectStore.getAllKeys.</title> <title>IndexedDB: Test IDBObjectStore.getAllKeys.</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split(''); var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) { function getall_test(func, name) {
var delete_request = indexedDB.deleteDatabase(dbName); indexeddb_test(
delete_request.onerror = function() { function(t, connection, tx) {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
var store = connection.createObjectStore('generated', var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'}); {autoIncrement: true, keyPath: 'id'});
alphabet.forEach(function(letter) { alphabet.forEach(function(letter) {
@ -33,8 +22,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
}); });
store = connection.createObjectStore('empty', null); store = connection.createObjectStore('empty', null);
}; },
}; func,
name
);
} }
function createGetAllKeysRequest(t, storeName, connection, range, maxCount) { function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
@ -45,9 +36,7 @@ function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
return req; return req;
} }
doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) { getall_test(function(t, connection) {
var connection = evt.target.result;
async_test(function(t) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'c'); var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'c');
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, ['c']); assert_array_equals(evt.target.result, ['c']);
@ -55,7 +44,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Single item get'); }, 'Single item get');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection, 3); var req = createGetAllKeysRequest(t, 'generated', connection, 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result; var data = evt.target.result;
@ -65,7 +54,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Single item get (generated key)'); }, 'Single item get (generated key)');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'empty', connection); var req = createGetAllKeysRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [], assert_array_equals(evt.target.result, [],
@ -75,7 +64,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'getAllKeys on empty object store'); }, 'getAllKeys on empty object store');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection); var req = createGetAllKeysRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, alphabet); assert_array_equals(evt.target.result, alphabet);
@ -83,7 +72,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get all values'); }, 'Get all values');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined, var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
10); 10);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -92,7 +81,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Test maxCount'); }, 'Test maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm')); IDBKeyRange.bound('g', 'm'));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -101,7 +90,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range'); }, 'Get bound range');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'), 3); IDBKeyRange.bound('g', 'm'), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -110,7 +99,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range with maxCount'); }, 'Get bound range with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', false, true)); IDBKeyRange.bound('g', 'k', false, true));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -119,7 +108,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get upper excluded'); }, 'Get upper excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', true, false)); IDBKeyRange.bound('g', 'k', true, false));
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -128,7 +117,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get lower excluded'); }, 'Get lower excluded');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection, var req = createGetAllKeysRequest(t, 'generated', connection,
IDBKeyRange.bound(4, 15), 3); IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -139,7 +128,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'Get bound range (generated) with maxCount'); }, 'Get bound range (generated) with maxCount');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, var req = createGetAllKeysRequest(t, 'out-of-line', connection,
"Doesn't exist"); "Doesn't exist");
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -151,7 +140,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
req.onerror = t.unreached_func('getAllKeys request should succeed'); req.onerror = t.unreached_func('getAllKeys request should succeed');
}, 'Non existent key'); }, 'Non existent key');
async_test(function(t) { getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined, var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
0); 0);
req.onsuccess = t.step_func(function(evt) { req.onsuccess = t.step_func(function(evt) {
@ -160,8 +149,4 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
}); });
}, 'zero maxCount'); }, 'zero maxCount');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script> </script>

21
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getKey.html
View file

@ -4,17 +4,12 @@
<meta name=timeout content=long> <meta name=timeout content=long>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
function getkey_test(func, name) { function getkey_test(func, name) {
return async_test(function(t) { indexeddb_test(
var del = indexedDB.deleteDatabase(name); function(t, db, tx) {
del.onerror = t.unreached_func('deleteDatabase failed');
var open = indexedDB.open(name);
open.onerror = t.unreached_func('open failed');
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
var basic = db.createObjectStore('basic'); var basic = db.createObjectStore('basic');
var key_path_store = db.createObjectStore('key path', var key_path_store = db.createObjectStore('key path',
{keyPath: 'id'}); {keyPath: 'id'});
@ -30,12 +25,10 @@ function getkey_test(func, name) {
key_generator_store.put('value: ' + i); key_generator_store.put('value: ' + i);
key_generator_and_path_store.put({}); key_generator_and_path_store.put({});
} }
}); },
open.onsuccess = t.step_func(function() { func,
var db = open.result; name
func(t, db); );
});
}, name);
} }
getkey_test(function(t, db) { getkey_test(function(t, db) {

33
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_openCursor_invalid.htm
View file

@ -4,28 +4,17 @@
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var db, open; indexeddb_test(
function(t, db, tx) {
setup(function() {
open = indexedDB.open('testdb-' + new Date().getTime());
open.onupgradeneeded = function(e) {
db = e.target.result;
var objStore = db.createObjectStore("test"); var objStore = db.createObjectStore("test");
objStore.createIndex("index", ""); objStore.createIndex("index", "");
objStore.add("data", 1); objStore.add("data", 1);
objStore.add("data2", 2); objStore.add("data2", 2);
}; },
}, function(t, db, tx) {
{ explicit_done: true });
open.onsuccess = function() {
async_test(document.title + " - pass something other than number").step(function(e) {
var idx = db.transaction("test").objectStore("test").index("index"); var idx = db.transaction("test").objectStore("test").index("index");
assert_throws("DataError", assert_throws("DataError",
@ -37,14 +26,8 @@
assert_throws("DataError", assert_throws("DataError",
function() { idx.openCursor({ lower: "a", lowerOpen: false, upper: null, upperOpen: false }); }); function() { idx.openCursor({ lower: "a", lowerOpen: false, upper: null, upperOpen: false }); });
this.done(); t.done();
}); },
document.title + " - pass something other than number"
);
// Stop blocking the testing system from hereon
done();
}
</script> </script>
<div id="log"></div>

30
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_openKeyCursor.htm
View file

@ -2,26 +2,20 @@
<title>IDBObjectStore.openKeyCursor()</title> <title>IDBObjectStore.openKeyCursor()</title>
<script src="/resources/testharness.js"></script> <script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script> <script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script> <script>
function store_test(func, name) { function store_test(func, name) {
async_test(function(t) { indexeddb_test(
var del = indexedDB.deleteDatabase(name); function(t, db, tx) {
del.onerror = t.unreached_func("deleteDatabase failed"); var store = db.createObjectStore("store");
var open = indexedDB.open(name); for (var i = 0; i < 10; ++i) {
open.onupgradeneeded = t.step_func(function() { store.put("value: " + i, i);
var db = open.result; }
var store = db.createObjectStore("store"); },
for (var i = 0; i < 10; ++i) { function(t, db) {
store.put("value: " + i, i); var tx = db.transaction("store");
} var store = tx.objectStore("store");
}); func(t, db, tx, store);
open.onsuccess = t.step_func(function() {
var db = open.result;
var tx = db.transaction("store");
var store = tx.objectStore("store");
func(t, db, tx, store);
});
}, name); }, name);
} }

6
tests/wpt/web-platform-tests/IndexedDB/idbrequest-onupgradeneeded.htm
View file

@ -16,6 +16,12 @@ function upgradeneeded_test(upgrade_func, success_func, error_func, description)
var open_request = indexedDB.open(dbName); var open_request = indexedDB.open(dbName);
open_request.onupgradeneeded = t.step_func(function() { open_request.onupgradeneeded = t.step_func(function() {
t.add_cleanup(function() {
if (open_request.result) {
open_request.result.close(),
indexedDB.deleteDatabase(dbName);
}
});
upgrade_func(t, open_request); upgrade_func(t, open_request);
}); });
open_request.onsuccess = t.step_func(function() { open_request.onsuccess = t.step_func(function() {

71
tests/wpt/web-platform-tests/IndexedDB/idbtransaction.htm
View file

@ -6,41 +6,54 @@
<script src="support.js"></script> <script src="support.js"></script>
<script> <script>
var db, async_test(function(t) {
t = async_test(document.title + " - request gotten by the handler"), var open_rq = indexedDB.open("idbtransaction-" + document.location + t.name);
open_t = async_test(document.title + " - request returned by open()"),
open_rq = indexedDB.open("idbtransaction-" + new Date().getTime() + Math.random()); open_rq.onblocked = t.unreached_func('open_rq.onblocked');
open_rq.onerror = t.unreached_func('open_rq.onerror');
open_t.step(function() { open_rq.onupgradeneeded = t.step_func(function(e) {
assert_equals(open_rq.transaction, null, "IDBOpenDBRequest.transaction"); t.add_cleanup(function() {
assert_equals(open_rq.source, null, "IDBOpenDBRequest.source"); open_rq.onerror = function(e) {
assert_equals(open_rq.readyState, "pending", "IDBOpenDBRequest.readyState"); e.preventDefault();
};
assert_true(open_rq instanceof IDBOpenDBRequest, "open_rq instanceof IDBOpenDBRequest"); open_rq.result.close();
assert_equals(open_rq + "", "[object IDBOpenDBRequest]", "IDBOpenDBRequest (open_rq)"); indexedDB.deleteDatabase(open_rq.result.name);
open_t.done();
}); });
open_rq.onupgradeneeded = t.step_func(function(e) { assert_equals(e.target, open_rq, "e.target is reusing the same IDBOpenDBRequest");
assert_equals(e.target, open_rq, "e.target is reusing the same IDBOpenDBRequest"); assert_equals(e.target.transaction, open_rq.transaction, "IDBOpenDBRequest.transaction");
assert_equals(e.target.transaction, open_rq.transaction, "IDBOpenDBRequest.transaction");
assert_true(e.target.transaction instanceof IDBTransaction, "transaction instanceof IDBTransaction"); assert_true(e.target.transaction instanceof IDBTransaction, "transaction instanceof IDBTransaction");
t.done(); t.done();
});
}, document.title + " - request gotten by the handler");
async_test(function(t) {
var open_rq = indexedDB.open("idbtransaction-" + document.location + t.name);
assert_equals(open_rq.transaction, null, "IDBOpenDBRequest.transaction");
assert_equals(open_rq.source, null, "IDBOpenDBRequest.source");
assert_equals(open_rq.readyState, "pending", "IDBOpenDBRequest.readyState");
assert_true(open_rq instanceof IDBOpenDBRequest, "open_rq instanceof IDBOpenDBRequest");
assert_equals(open_rq + "", "[object IDBOpenDBRequest]", "IDBOpenDBRequest (open_rq)");
open_rq.onblocked = t.unreached_func('open_rq.onblocked');
open_rq.onerror = t.unreached_func('open_rq.onerror');
open_rq.onupgradeneeded = t.step_func(function() {
t.add_cleanup(function() {
open_rq.onerror = function(e) {
e.preventDefault();
};
open_rq.result.close();
indexedDB.deleteDatabase(open_rq.result.name);
}); });
t.done();
});
}, document.title + " - request returned by open()");
// Not plausible conditions...
function fail_helper(name) {
return function() {
t.step(function() { assert_unreached(name); });
open_t.step(function() { assert_unreached(name); });
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
</script> </script>
<div id="log"></div>

Some files were not shown because too many files have changed in this diff Show more