From bd05e23d40ef390c849d83bf24d48324f6eaaa76 Mon Sep 17 00:00:00 2001 From: Kevin Gibbons Date: Sun, 21 Jan 2024 17:09:11 -0800 Subject: [PATCH] add tests for base64 proposal --- features.txt | 4 + .../Uint8Array/fromBase64/alphabet.js | 22 +++ .../Uint8Array/fromBase64/descriptor.js | 15 ++ .../Uint8Array/fromBase64/ignores-receiver.js | 19 +++ .../fromBase64/illegal-characters.js | 23 +++ .../fromBase64/last-chunk-handling.js | 50 +++++++ .../built-ins/Uint8Array/fromBase64/length.js | 16 +++ test/built-ins/Uint8Array/fromBase64/name.js | 16 +++ .../Uint8Array/fromBase64/nonconstructor.js | 15 ++ .../Uint8Array/fromBase64/option-coercion.js | 50 +++++++ .../Uint8Array/fromBase64/results.js | 25 ++++ .../Uint8Array/fromBase64/string-coercion.js | 41 ++++++ .../Uint8Array/fromBase64/whitespace.js | 20 +++ .../Uint8Array/fromBase64Into/alphabet.js | 41 ++++++ .../Uint8Array/fromBase64Into/descriptor.js | 15 ++ .../fromBase64Into/detached-buffer.js | 29 ++++ .../fromBase64Into/ignores-receiver.js | 16 +++ .../fromBase64Into/illegal-characters.js | 24 ++++ .../fromBase64Into/last-chunk-handling.js | 131 ++++++++++++++++++ .../Uint8Array/fromBase64Into/length.js | 16 +++ .../Uint8Array/fromBase64Into/name.js | 16 +++ .../fromBase64Into/nonconstructor.js | 16 +++ .../fromBase64Into/option-coercion.js | 58 ++++++++ .../Uint8Array/fromBase64Into/results.js | 30 ++++ .../fromBase64Into/string-coercion.js | 43 ++++++ .../Uint8Array/fromBase64Into/subarray.js | 17 +++ .../Uint8Array/fromBase64Into/target-size.js | 64 +++++++++ .../Uint8Array/fromBase64Into/whitespace.js | 23 +++ .../Uint8Array/fromHex/descriptor.js | 15 ++ .../Uint8Array/fromHex/ignores-receiver.js | 19 +++ .../Uint8Array/fromHex/illegal-characters.js | 25 ++++ test/built-ins/Uint8Array/fromHex/length.js | 16 +++ test/built-ins/Uint8Array/fromHex/name.js | 16 +++ .../Uint8Array/fromHex/nonconstructor.js | 15 ++ .../Uint8Array/fromHex/odd-length-input.js | 11 ++ test/built-ins/Uint8Array/fromHex/results.js | 26 ++++ .../Uint8Array/fromHex/string-coercion.js | 20 +++ .../Uint8Array/fromHexInto/descriptor.js | 15 ++ .../Uint8Array/fromHexInto/detached-buffer.js | 14 ++ .../fromHexInto/ignores-receiver.js | 16 +++ .../fromHexInto/illegal-characters.js | 26 ++++ .../Uint8Array/fromHexInto/length.js | 16 +++ test/built-ins/Uint8Array/fromHexInto/name.js | 16 +++ .../Uint8Array/fromHexInto/nonconstructor.js | 16 +++ .../Uint8Array/fromHexInto/results.js | 31 +++++ .../Uint8Array/fromHexInto/string-coercion.js | 21 +++ .../Uint8Array/fromHexInto/subarray.js | 17 +++ .../Uint8Array/fromHexInto/target-size.js | 29 ++++ .../Uint8Array/prototype/toBase64/alphabet.js | 17 +++ .../prototype/toBase64/descriptor.js | 15 ++ .../prototype/toBase64/detached-buffer.js | 39 ++++++ .../Uint8Array/prototype/toBase64/length.js | 16 +++ .../Uint8Array/prototype/toBase64/name.js | 16 +++ .../prototype/toBase64/nonconstructor.js | 16 +++ .../prototype/toBase64/option-coercion.js | 43 ++++++ .../toBase64/receiver-not-uint8array.js | 33 +++++ .../Uint8Array/prototype/toBase64/results.js | 16 +++ .../Uint8Array/prototype/toHex/descriptor.js | 15 ++ .../prototype/toHex/detached-buffer.js | 15 ++ .../Uint8Array/prototype/toHex/length.js | 16 +++ .../Uint8Array/prototype/toHex/name.js | 16 +++ .../prototype/toHex/nonconstructor.js | 16 +++ .../toHex/receiver-not-uint8array.js | 26 ++++ .../Uint8Array/prototype/toHex/results.js | 15 ++ 64 files changed, 1565 insertions(+) create mode 100644 test/built-ins/Uint8Array/fromBase64/alphabet.js create mode 100644 test/built-ins/Uint8Array/fromBase64/descriptor.js create mode 100644 test/built-ins/Uint8Array/fromBase64/ignores-receiver.js create mode 100644 test/built-ins/Uint8Array/fromBase64/illegal-characters.js create mode 100644 test/built-ins/Uint8Array/fromBase64/last-chunk-handling.js create mode 100644 test/built-ins/Uint8Array/fromBase64/length.js create mode 100644 test/built-ins/Uint8Array/fromBase64/name.js create mode 100644 test/built-ins/Uint8Array/fromBase64/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/fromBase64/option-coercion.js create mode 100644 test/built-ins/Uint8Array/fromBase64/results.js create mode 100644 test/built-ins/Uint8Array/fromBase64/string-coercion.js create mode 100644 test/built-ins/Uint8Array/fromBase64/whitespace.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/alphabet.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/descriptor.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/detached-buffer.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/ignores-receiver.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/illegal-characters.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/last-chunk-handling.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/length.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/name.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/option-coercion.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/results.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/string-coercion.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/subarray.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/target-size.js create mode 100644 test/built-ins/Uint8Array/fromBase64Into/whitespace.js create mode 100644 test/built-ins/Uint8Array/fromHex/descriptor.js create mode 100644 test/built-ins/Uint8Array/fromHex/ignores-receiver.js create mode 100644 test/built-ins/Uint8Array/fromHex/illegal-characters.js create mode 100644 test/built-ins/Uint8Array/fromHex/length.js create mode 100644 test/built-ins/Uint8Array/fromHex/name.js create mode 100644 test/built-ins/Uint8Array/fromHex/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/fromHex/odd-length-input.js create mode 100644 test/built-ins/Uint8Array/fromHex/results.js create mode 100644 test/built-ins/Uint8Array/fromHex/string-coercion.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/descriptor.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/detached-buffer.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/ignores-receiver.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/illegal-characters.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/length.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/name.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/results.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/string-coercion.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/subarray.js create mode 100644 test/built-ins/Uint8Array/fromHexInto/target-size.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/alphabet.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/descriptor.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/detached-buffer.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/length.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/name.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/option-coercion.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/receiver-not-uint8array.js create mode 100644 test/built-ins/Uint8Array/prototype/toBase64/results.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/descriptor.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/detached-buffer.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/length.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/name.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/nonconstructor.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/receiver-not-uint8array.js create mode 100644 test/built-ins/Uint8Array/prototype/toHex/results.js diff --git a/features.txt b/features.txt index 1a43df40dd..51e88dbd5b 100644 --- a/features.txt +++ b/features.txt @@ -131,6 +131,10 @@ source-phase-imports ## test262 special specifier source-phase-imports-module-source +# Uint8Array Base64 +# https://github.com/tc39/proposal-arraybuffer-base64 +uint8array-base64 + ## Standard language features # # Language features that have been included in a published version of the diff --git a/test/built-ins/Uint8Array/fromBase64/alphabet.js b/test/built-ins/Uint8Array/fromBase64/alphabet.js new file mode 100644 index 0000000000..a5d28b7a1a --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/alphabet.js @@ -0,0 +1,22 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Conversion of base64 strings to Uint8Arrays exercising the alphabet option +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +assert.compareArray(Uint8Array.fromBase64('x+/y'), [199, 239, 242]); +assert.compareArray(Uint8Array.fromBase64('x+/y', { alphabet: 'base64' }), [199, 239, 242]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('x+/y', { alphabet: 'base64url' }); +}); + +assert.compareArray(Uint8Array.fromBase64('x-_y', { alphabet: 'base64url' }), [199, 239, 242]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('x-_y'); +}); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('x-_y', { alphabet: 'base64' }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64/descriptor.js b/test/built-ins/Uint8Array/fromBase64/descriptor.js new file mode 100644 index 0000000000..dfcc913a3c --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: > + Uint8Array.fromBase64 has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array, 'fromBase64', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64/ignores-receiver.js b/test/built-ins/Uint8Array/fromBase64/ignores-receiver.js new file mode 100644 index 0000000000..811ebc517a --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/ignores-receiver.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64 ignores its receiver +features: [uint8array-base64] +---*/ + +var fromBase64 = Uint8Array.fromBase64; +var noReceiver = fromBase64("Zg=="); +assert.sameValue(Object.getPrototypeOf(noReceiver), Uint8Array.prototype); + +class Subclass extends Uint8Array { + constructor() { + throw new Test262Error("subclass constructor called"); + } +} +var fromSubclass = Subclass.fromBase64("Zg=="); +assert.sameValue(Object.getPrototypeOf(fromSubclass), Uint8Array.prototype); diff --git a/test/built-ins/Uint8Array/fromBase64/illegal-characters.js b/test/built-ins/Uint8Array/fromBase64/illegal-characters.js new file mode 100644 index 0000000000..5f2d7a8438 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/illegal-characters.js @@ -0,0 +1,23 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64 throws a SyntaxError when input has non-base64, non-ascii-whitespace characters +features: [uint8array-base64] +---*/ + +var illegal = [ + 'Zm.9v', + 'Zm9v^', + 'Zg==&', + 'Z−==', // U+2212 'Minus Sign' + 'Z＋==', // U+FF0B 'Fullwidth Plus Sign' + 'Zg\u00A0==', // nbsp + 'Zg\u2009==', // thin space + 'Zg\u2028==', // line separator +]; +illegal.forEach(function(value) { + assert.throws(SyntaxError, function() { + Uint8Array.fromBase64(value) + }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64/last-chunk-handling.js b/test/built-ins/Uint8Array/fromBase64/last-chunk-handling.js new file mode 100644 index 0000000000..edade6f2ab --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/last-chunk-handling.js @@ -0,0 +1,50 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Handling of final chunks in Uint8Array.fromBase64 +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// padding +assert.compareArray(Uint8Array.fromBase64('ZXhhZg=='), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg==', { lastChunkHandling: 'strict' }), [101, 120, 97, 102]); + +// no padding +assert.compareArray(Uint8Array.fromBase64('ZXhhZg'), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZg', { lastChunkHandling: 'strict' }); +}); + +// non-zero padding bits +assert.compareArray(Uint8Array.fromBase64('ZXhhZh=='), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97, 102]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZh==', { lastChunkHandling: 'strict' }); +}); + +// non-zero padding bits, no padding +assert.compareArray(Uint8Array.fromBase64('ZXhhZh'), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'loose' }), [101, 120, 97, 102]); +assert.compareArray(Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZh', { lastChunkHandling: 'strict' }); +}); + +// malformed padding +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZg='); +}); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'loose' }); +}); +assert.compareArray(Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'stop-before-partial' }), [101, 120, 97]); +assert.throws(SyntaxError, function() { + Uint8Array.fromBase64('ZXhhZg=', { lastChunkHandling: 'strict' }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64/length.js b/test/built-ins/Uint8Array/fromBase64/length.js new file mode 100644 index 0000000000..23b7072954 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: > + Uint8Array.fromBase64.length is 1. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromBase64, 'length', { + value: 1, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64/name.js b/test/built-ins/Uint8Array/fromBase64/name.js new file mode 100644 index 0000000000..9e38d3158e --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: > + Uint8Array.fromBase64.name is "fromBase64". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromBase64, 'name', { + value: 'fromBase64', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64/nonconstructor.js b/test/built-ins/Uint8Array/fromBase64/nonconstructor.js new file mode 100644 index 0000000000..219e6399f2 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/nonconstructor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: > + Uint8Array.fromBase64 is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.fromBase64), "Uint8Array.fromBase64 is not a constructor"); + +assert.throws(TypeError, function() { + new Uint8Array.fromBase64(''); +}); diff --git a/test/built-ins/Uint8Array/fromBase64/option-coercion.js b/test/built-ins/Uint8Array/fromBase64/option-coercion.js new file mode 100644 index 0000000000..917aa3d1b5 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/option-coercion.js @@ -0,0 +1,50 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64 triggers effects of the "alphabet" and "lastChunkHandling" getters, but does not perform toString on the results +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; +assert.throws(TypeError, function() { + Uint8Array.fromBase64("Zg==", { alphabet: throwyToString }); +}); +assert.sameValue(toStringCalls, 0); + +assert.throws(TypeError, function() { + Uint8Array.fromBase64("Zg==", { lastChunkHandling: throwyToString }); +}); +assert.sameValue(toStringCalls, 0); + + +var alphabetAccesses = 0; +var base64UrlOptions = {}; +Object.defineProperty(base64UrlOptions, "alphabet", { + get: function() { + alphabetAccesses += 1; + return "base64url"; + } +}); +var arr = Uint8Array.fromBase64("x-_y", base64UrlOptions); +assert.compareArray(arr, [199, 239, 242]); +assert.sameValue(alphabetAccesses, 1); + +var lastChunkHandlingAccesses = 0; +var strictOptions = {}; +Object.defineProperty(strictOptions, "lastChunkHandling", { + get: function() { + lastChunkHandlingAccesses += 1; + return "strict"; + } +}); +var arr = Uint8Array.fromBase64("Zg==", strictOptions); +assert.compareArray(arr, [102]); +assert.sameValue(lastChunkHandlingAccesses, 1); diff --git a/test/built-ins/Uint8Array/fromBase64/results.js b/test/built-ins/Uint8Array/fromBase64/results.js new file mode 100644 index 0000000000..48910c32cf --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/results.js @@ -0,0 +1,25 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Conversion of base64 strings to Uint8Arrays +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// standard test vectors from https://datatracker.ietf.org/doc/html/rfc4648#section-10 +var standardBase64Vectors = [ + ["", []], + ["Zg==", [102]], + ["Zm8=", [102, 111]], + ["Zm9v", [102, 111, 111]], + ["Zm9vYg==", [102, 111, 111, 98]], + ["Zm9vYmE=", [102, 111, 111, 98, 97]], + ["Zm9vYmFy", [102, 111, 111, 98, 97, 114]], +]; + +standardBase64Vectors.forEach(function (pair) { + var arr = Uint8Array.fromBase64(pair[0]); + assert.sameValue(Object.getPrototypeOf(arr), Uint8Array.prototype, "decoding " + pair[0]); + assert.compareArray(arr, pair[1], "decoding " + pair[0]); +}); diff --git a/test/built-ins/Uint8Array/fromBase64/string-coercion.js b/test/built-ins/Uint8Array/fromBase64/string-coercion.js new file mode 100644 index 0000000000..56f0648330 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/string-coercion.js @@ -0,0 +1,41 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64 throws if its argument is not a string +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; + +assert.throws(TypeError, function() { + Uint8Array.fromBase64(throwyToString); +}); +assert.sameValue(toStringCalls, 0); + + +var optionAccesses = 0; +var touchyOptions = {}; +Object.defineProperty(touchyOptions, "alphabet", { + get: function() { + optionAccesses += 1; + throw new Test262Error("alphabet accessed"); + } +}); +Object.defineProperty(touchyOptions, "lastChunkHandling", { + get: function() { + optionAccesses += 1; + throw new Test262Error("lastChunkHandling accessed"); + } +}); +assert.throws(TypeError, function() { + Uint8Array.fromBase64(throwyToString, touchyOptions); +}); +assert.sameValue(toStringCalls, 0); +assert.sameValue(optionAccesses, 0); diff --git a/test/built-ins/Uint8Array/fromBase64/whitespace.js b/test/built-ins/Uint8Array/fromBase64/whitespace.js new file mode 100644 index 0000000000..ce9f7f239c --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64/whitespace.js @@ -0,0 +1,20 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64 ignores ASCII whitespace in the input +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var whitespaceKinds = [ + ["Z g==", "space"], + ["Z\tg==", "tab"], + ["Z\x0Ag==", "LF"], + ["Z\x0Cg==", "FF"], + ["Z\x0Dg==", "CR"], +]; +whitespaceKinds.forEach(function(pair) { + var arr = Uint8Array.fromBase64(pair[0]); + assert.compareArray(arr, [102], "ascii whitespace: " + pair[1]); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/alphabet.js b/test/built-ins/Uint8Array/fromBase64Into/alphabet.js new file mode 100644 index 0000000000..270396581c --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/alphabet.js @@ -0,0 +1,41 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Conversion of base64 strings to Uint8Arrays exercising the alphabet option +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('x+/y', target); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [199, 239, 242, 255]); + +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('x+/y', target, { alphabet: 'base64' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [199, 239, 242, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255]); + Uint8Array.fromBase64('x+/y', { alphabet: 'base64url' }); +}); + + +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('x-_y', target, { alphabet: 'base64url' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [199, 239, 242, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255]); + Uint8Array.fromBase64('x-_y'); +}); +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255]); + Uint8Array.fromBase64('x-_y', { alphabet: 'base64' }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/descriptor.js b/test/built-ins/Uint8Array/fromBase64Into/descriptor.js new file mode 100644 index 0000000000..672a29cb6a --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: > + Uint8Array.fromBase64Into has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array, 'fromBase64Into', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/detached-buffer.js b/test/built-ins/Uint8Array/fromBase64Into/detached-buffer.js new file mode 100644 index 0000000000..80ebbcf4f4 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/detached-buffer.js @@ -0,0 +1,29 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into does not write to or error on detatched buffers +includes: [detachArrayBuffer.js] +features: [uint8array-base64] +---*/ + +var target = new Uint8Array([255, 255, 255]); +$DETACHBUFFER(target.buffer); +var result = Uint8Array.fromBase64Into('Zg==', target); +assert.sameValue(result.read, 0); +assert.sameValue(result.written, 0); + +var getterCalls = 0; +var targetDetachingOptions = {}; +Object.defineProperty(targetDetachingOptions, 'alphabet', { + get: function() { + getterCalls += 1; + $DETACHBUFFER(target.buffer); + return "base64"; + } +}); +var target = new Uint8Array([255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zg==', target, targetDetachingOptions); +assert.sameValue(getterCalls, 1); +assert.sameValue(result.read, 0); +assert.sameValue(result.written, 0); diff --git a/test/built-ins/Uint8Array/fromBase64Into/ignores-receiver.js b/test/built-ins/Uint8Array/fromBase64Into/ignores-receiver.js new file mode 100644 index 0000000000..55d3bb96cb --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/ignores-receiver.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into ignores its receiver +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var fromBase64Into = Uint8Array.fromBase64Into; +var target = new Uint8Array([255, 255, 255]); + +var result = fromBase64Into("Zg==", target); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 1); +assert.compareArray(target, [102, 255, 255]); diff --git a/test/built-ins/Uint8Array/fromBase64Into/illegal-characters.js b/test/built-ins/Uint8Array/fromBase64Into/illegal-characters.js new file mode 100644 index 0000000000..899d934c91 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/illegal-characters.js @@ -0,0 +1,24 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64 throws a SyntaxError when input has non-base64, non-ascii-whitespace characters +features: [uint8array-base64] +---*/ + +var illegal = [ + 'Zm.9v', + 'Zm9v^', + 'Zg==&', + 'Z−==', // U+2212 'Minus Sign' + 'Z＋==', // U+FF0B 'Fullwidth Plus Sign' + 'Zg\u00A0==', // nbsp + 'Zg\u2009==', // thin space + 'Zg\u2028==', // line separator +]; +illegal.forEach(function(value) { + assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into(value, target); + }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/last-chunk-handling.js b/test/built-ins/Uint8Array/fromBase64Into/last-chunk-handling.js new file mode 100644 index 0000000000..1c0ab248d6 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/last-chunk-handling.js @@ -0,0 +1,131 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Handling of final chunks in Uint8Array.fromBase64Into +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// padding +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg==', target); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg==', target, { lastChunkHandling: 'loose' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg==', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg==', target, { lastChunkHandling: 'strict' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + + +// no padding +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg', target); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg', target, { lastChunkHandling: 'loose' }); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [101, 120, 97, 255, 255, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZg', target, { lastChunkHandling: 'strict' }); +}); + + +// non-zero padding bits +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh==', target); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh==', target, { lastChunkHandling: 'loose' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh==', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZh==', target, { lastChunkHandling: 'strict' }); +}); + + +// non-zero padding bits, no padding +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh', target); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh', target, { lastChunkHandling: 'loose' }); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 4); +assert.compareArray(target, [101, 120, 97, 102, 255, 255]); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZh', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [101, 120, 97, 255, 255, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZh', target, { lastChunkHandling: 'strict' }); +}); + + +// malformed padding +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZg=', target); +}); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZg=', target, { lastChunkHandling: 'loose' }); +}); + +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('ZXhhZg=', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [101, 120, 97, 255, 255, 255]); + +assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255, 255]); + Uint8Array.fromBase64Into('ZXhhZg=', target, { lastChunkHandling: 'strict' }); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/length.js b/test/built-ins/Uint8Array/fromBase64Into/length.js new file mode 100644 index 0000000000..a97be01f69 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: > + Uint8Array.fromBase64Into.length is 2. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromBase64Into, 'length', { + value: 2, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/name.js b/test/built-ins/Uint8Array/fromBase64Into/name.js new file mode 100644 index 0000000000..dcdc49c99b --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: > + Uint8Array.fromBase64Into.name is "fromBase64Into". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromBase64Into, 'name', { + value: 'fromBase64Into', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/nonconstructor.js b/test/built-ins/Uint8Array/fromBase64Into/nonconstructor.js new file mode 100644 index 0000000000..a5e9f0ec7a --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/nonconstructor.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: > + Uint8Array.fromBase64Into is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.fromBase64Into), "Uint8Array.fromBase64Into is not a constructor"); + +assert.throws(TypeError, function() { + var target = new Uint8Array(10); + new Uint8Array.fromBase64Into('', target); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/option-coercion.js b/test/built-ins/Uint8Array/fromBase64Into/option-coercion.js new file mode 100644 index 0000000000..174712f932 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/option-coercion.js @@ -0,0 +1,58 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into triggers effects of the "alphabet" and "lastChunkHandling" getters, but does not perform toString on the results +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; +assert.throws(TypeError, function() { + var target = new Uint8Array([255, 255, 255]); + Uint8Array.fromBase64Into("Zg==", target, { alphabet: throwyToString }); +}); +assert.sameValue(toStringCalls, 0); + +assert.throws(TypeError, function() { + var target = new Uint8Array([255, 255, 255]); + Uint8Array.fromBase64Into("Zg==", target, { lastChunkHandling: throwyToString }); +}); +assert.sameValue(toStringCalls, 0); + + +var alphabetAccesses = 0; +var base64UrlOptions = {}; +Object.defineProperty(base64UrlOptions, "alphabet", { + get: function() { + alphabetAccesses += 1; + return "base64url"; + } +}); +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into("x-_y", target, base64UrlOptions); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [199, 239, 242, 255]); +assert.sameValue(alphabetAccesses, 1); + +var lastChunkHandlingAccesses = 0; +var strictOptions = {}; +Object.defineProperty(strictOptions, "lastChunkHandling", { + get: function() { + lastChunkHandlingAccesses += 1; + return "strict"; + } +}); +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into("Zg==", target, strictOptions); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 1); +assert.compareArray(target, [102, 255, 255, 255]); +assert.sameValue(lastChunkHandlingAccesses, 1); diff --git a/test/built-ins/Uint8Array/fromBase64Into/results.js b/test/built-ins/Uint8Array/fromBase64Into/results.js new file mode 100644 index 0000000000..35b02b4078 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/results.js @@ -0,0 +1,30 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Conversion of base64 strings to Uint8Arrays +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// standard test vectors from https://datatracker.ietf.org/doc/html/rfc4648#section-10 +var standardBase64Vectors = [ + ["", []], + ["Zg==", [102]], + ["Zm8=", [102, 111]], + ["Zm9v", [102, 111, 111]], + ["Zm9vYg==", [102, 111, 111, 98]], + ["Zm9vYmE=", [102, 111, 111, 98, 97]], + ["Zm9vYmFy", [102, 111, 111, 98, 97, 114]], +]; + +standardBase64Vectors.forEach(function (pair) { + var allFF = [255, 255, 255, 255, 255, 255, 255, 255]; + var target = new Uint8Array(allFF); + var result = Uint8Array.fromBase64Into(pair[0], target); + assert.sameValue(result.read, pair[0].length); + assert.sameValue(result.written, pair[1].length); + + var expected = pair[1].concat(allFF.slice(pair[1].length)) + assert.compareArray(target, expected, "decoding " + pair[0]); +}); diff --git a/test/built-ins/Uint8Array/fromBase64Into/string-coercion.js b/test/built-ins/Uint8Array/fromBase64Into/string-coercion.js new file mode 100644 index 0000000000..17ad8b48f6 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/string-coercion.js @@ -0,0 +1,43 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into throws if its first argument is not a string +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; + +assert.throws(TypeError, function() { + var target = new Uint8Array(10); + Uint8Array.fromBase64Into(throwyToString, target); +}); +assert.sameValue(toStringCalls, 0); + + +var optionAccesses = 0; +var touchyOptions = {}; +Object.defineProperty(touchyOptions, "alphabet", { + get: function() { + optionAccesses += 1; + throw new Test262Error("alphabet accessed"); + } +}); +Object.defineProperty(touchyOptions, "lastChunkHandling", { + get: function() { + optionAccesses += 1; + throw new Test262Error("lastChunkHandling accessed"); + } +}); +assert.throws(TypeError, function() { + var target = new Uint8Array(10); + Uint8Array.fromBase64Into(throwyToString, target, touchyOptions); +}); +assert.sameValue(toStringCalls, 0); +assert.sameValue(optionAccesses, 0); diff --git a/test/built-ins/Uint8Array/fromBase64Into/subarray.js b/test/built-ins/Uint8Array/fromBase64Into/subarray.js new file mode 100644 index 0000000000..6c5bb95e54 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/subarray.js @@ -0,0 +1,17 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into takes into account the offset of the target Uint8Array +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var base = new Uint8Array([255, 255, 255, 255, 255, 255, 255]); +var subarray = base.subarray(2, 5); + +var result = Uint8Array.fromBase64Into('Zm9vYmFy', subarray); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(subarray, [102, 111, 111]); +assert.compareArray(base, [255, 255, 102, 111, 111, 255, 255]); diff --git a/test/built-ins/Uint8Array/fromBase64Into/target-size.js b/test/built-ins/Uint8Array/fromBase64Into/target-size.js new file mode 100644 index 0000000000..4b44c9eaef --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/target-size.js @@ -0,0 +1,64 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64 +description: Uint8Array.fromBase64Into behavior when target buffer is small +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// buffer too small +var target = new Uint8Array([255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmFy', target); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [102, 111, 111, 255, 255]); + +// buffer too small, padded +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmE=', target); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [102, 111, 111, 255]); + +// buffer exact +var target = new Uint8Array([255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmFy', target); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 6); +assert.compareArray(target, [102, 111, 111, 98, 97, 114]); + +// buffer exact, padded +var target = new Uint8Array([255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmE=', target); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 5); +assert.compareArray(target, [102, 111, 111, 98, 97]); + +// buffer exact, not padded +var target = new Uint8Array([255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmE', target); +assert.sameValue(result.read, 7); +assert.sameValue(result.written, 5); +assert.compareArray(target, [102, 111, 111, 98, 97]); + +// buffer exact, padded, stop-before-partial +var target = new Uint8Array([255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmE=', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 5); +assert.compareArray(target, [102, 111, 111, 98, 97]); + +// buffer exact, not padded, stop-before-partial +var target = new Uint8Array([255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmE', target, { lastChunkHandling: 'stop-before-partial' }); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 3); +assert.compareArray(target, [102, 111, 111, 255, 255]); + +// buffer too large +var target = new Uint8Array([255, 255, 255, 255, 255, 255, 255]); +var result = Uint8Array.fromBase64Into('Zm9vYmFy', target); +assert.sameValue(result.read, 8); +assert.sameValue(result.written, 6); +assert.compareArray(target, [102, 111, 111, 98, 97, 114, 255]); diff --git a/test/built-ins/Uint8Array/fromBase64Into/whitespace.js b/test/built-ins/Uint8Array/fromBase64Into/whitespace.js new file mode 100644 index 0000000000..8ba0b01064 --- /dev/null +++ b/test/built-ins/Uint8Array/fromBase64Into/whitespace.js @@ -0,0 +1,23 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.frombase64into +description: Uint8Array.fromBase64Into ignores ASCII whitespace in the input +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var whitespaceKinds = [ + ["Z g==", "space"], + ["Z\tg==", "tab"], + ["Z\x0Ag==", "LF"], + ["Z\x0Cg==", "FF"], + ["Z\x0Dg==", "CR"], +]; +whitespaceKinds.forEach(function(pair) { + var target = new Uint8Array([255, 255, 255]); + var result = Uint8Array.fromBase64Into(pair[0], target); + assert.sameValue(result.read, 5); + assert.sameValue(result.written, 1); + assert.compareArray(target, [102, 255, 255], "ascii whitespace: " + pair[1]); +}); diff --git a/test/built-ins/Uint8Array/fromHex/descriptor.js b/test/built-ins/Uint8Array/fromHex/descriptor.js new file mode 100644 index 0000000000..1ae033cb1e --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: > + Uint8Array.fromHex has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array, 'fromHex', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHex/ignores-receiver.js b/test/built-ins/Uint8Array/fromHex/ignores-receiver.js new file mode 100644 index 0000000000..48bb0698c9 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/ignores-receiver.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: Uint8Array.fromHex ignores its receiver +features: [uint8array-base64] +---*/ + +var fromHex = Uint8Array.fromHex; +var noReceiver = fromHex("aa"); +assert.sameValue(Object.getPrototypeOf(noReceiver), Uint8Array.prototype); + +class Subclass extends Uint8Array { + constructor() { + throw new Test262Error("subclass constructor called"); + } +} +var fromSubclass = Subclass.fromHex("aa"); +assert.sameValue(Object.getPrototypeOf(fromSubclass), Uint8Array.prototype); diff --git a/test/built-ins/Uint8Array/fromHex/illegal-characters.js b/test/built-ins/Uint8Array/fromHex/illegal-characters.js new file mode 100644 index 0000000000..dd0ae6d55b --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/illegal-characters.js @@ -0,0 +1,25 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: Uint8Array.fromHex throws a SyntaxError when input has non-hex characters +features: [uint8array-base64] +---*/ + +var illegal = [ + 'a.a', + 'aa^', + 'a a', + 'a\ta', + 'a\x0Aa', + 'a\x0Ca', + 'a\x0Da', + 'a\u00A0a', // nbsp + 'a\u2009a', // thin space + 'a\u2028a', // line separator +]; +illegal.forEach(function(value) { + assert.throws(SyntaxError, function() { + Uint8Array.fromHex(value) + }); +}); diff --git a/test/built-ins/Uint8Array/fromHex/length.js b/test/built-ins/Uint8Array/fromHex/length.js new file mode 100644 index 0000000000..ef9dca8def --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: > + Uint8Array.fromHex.length is 1. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromHex, 'length', { + value: 1, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHex/name.js b/test/built-ins/Uint8Array/fromHex/name.js new file mode 100644 index 0000000000..083cff7b79 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: > + Uint8Array.fromHex.name is "fromHex". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromHex, 'name', { + value: 'fromHex', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHex/nonconstructor.js b/test/built-ins/Uint8Array/fromHex/nonconstructor.js new file mode 100644 index 0000000000..e06d1c54f3 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/nonconstructor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: > + Uint8Array.fromHex is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.fromHex), "Uint8Array.fromHex is not a constructor"); + +assert.throws(TypeError, function() { + new Uint8Array.fromHex(''); +}); diff --git a/test/built-ins/Uint8Array/fromHex/odd-length-input.js b/test/built-ins/Uint8Array/fromHex/odd-length-input.js new file mode 100644 index 0000000000..798be139c1 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/odd-length-input.js @@ -0,0 +1,11 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: Uint8Array.fromHex throws if given an odd number of input hex characters +features: [uint8array-base64] +---*/ + +assert.throws(SyntaxError, function() { + Uint8Array.fromHex('a'); +}); diff --git a/test/built-ins/Uint8Array/fromHex/results.js b/test/built-ins/Uint8Array/fromHex/results.js new file mode 100644 index 0000000000..58cd5648c5 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/results.js @@ -0,0 +1,26 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: Conversion of hex strings to Uint8Arrays +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var cases = [ + ["", []], + ["66", [102]], + ["666f", [102, 111]], + ["666F", [102, 111]], + ["666f6f", [102, 111, 111]], + ["666F6f", [102, 111, 111]], + ["666f6f62", [102, 111, 111, 98]], + ["666f6f6261", [102, 111, 111, 98, 97]], + ["666f6f626172", [102, 111, 111, 98, 97, 114]], +]; + +cases.forEach(function (pair) { + var arr = Uint8Array.fromHex(pair[0]); + assert.sameValue(Object.getPrototypeOf(arr), Uint8Array.prototype, "decoding " + pair[0]); + assert.compareArray(arr, pair[1], "decoding " + pair[0]); +}); diff --git a/test/built-ins/Uint8Array/fromHex/string-coercion.js b/test/built-ins/Uint8Array/fromHex/string-coercion.js new file mode 100644 index 0000000000..2290f25499 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHex/string-coercion.js @@ -0,0 +1,20 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhex +description: Uint8Array.fromHex throws if its argument is not a string +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; + +assert.throws(TypeError, function() { + Uint8Array.fromHex(throwyToString); +}); +assert.sameValue(toStringCalls, 0); diff --git a/test/built-ins/Uint8Array/fromHexInto/descriptor.js b/test/built-ins/Uint8Array/fromHexInto/descriptor.js new file mode 100644 index 0000000000..e26dea928b --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: > + Uint8Array.fromHexInto has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array, 'fromHexInto', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/detached-buffer.js b/test/built-ins/Uint8Array/fromHexInto/detached-buffer.js new file mode 100644 index 0000000000..0da1767acd --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/detached-buffer.js @@ -0,0 +1,14 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto does not write to or error on detatched buffers +includes: [detachArrayBuffer.js] +features: [uint8array-base64] +---*/ + +var target = new Uint8Array([255, 255, 255]); +$DETACHBUFFER(target.buffer); +var result = Uint8Array.fromHexInto('aa', target); +assert.sameValue(result.read, 0); +assert.sameValue(result.written, 0); diff --git a/test/built-ins/Uint8Array/fromHexInto/ignores-receiver.js b/test/built-ins/Uint8Array/fromHexInto/ignores-receiver.js new file mode 100644 index 0000000000..6c45490d19 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/ignores-receiver.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto ignores its receiver +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var fromHexInto = Uint8Array.fromHexInto; +var target = new Uint8Array([255, 255, 255]); + +var result = fromHexInto("aa", target); +assert.sameValue(result.read, 2); +assert.sameValue(result.written, 1); +assert.compareArray(target, [170, 255, 255]); diff --git a/test/built-ins/Uint8Array/fromHexInto/illegal-characters.js b/test/built-ins/Uint8Array/fromHexInto/illegal-characters.js new file mode 100644 index 0000000000..3b623f2197 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/illegal-characters.js @@ -0,0 +1,26 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto throws a SyntaxError when input has non-hex characters +features: [uint8array-base64] +---*/ + +var illegal = [ + 'a.a', + 'aa^', + 'a a', + 'a\ta', + 'a\x0Aa', + 'a\x0Ca', + 'a\x0Da', + 'a\u00A0a', // nbsp + 'a\u2009a', // thin space + 'a\u2028a', // line separator +]; +illegal.forEach(function(value) { + assert.throws(SyntaxError, function() { + var target = new Uint8Array([255, 255, 255, 255, 255]); + Uint8Array.fromHexInto(value, target); + }); +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/length.js b/test/built-ins/Uint8Array/fromHexInto/length.js new file mode 100644 index 0000000000..d41f524286 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: > + Uint8Array.fromHexInto.length is 2. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromHexInto, 'length', { + value: 2, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/name.js b/test/built-ins/Uint8Array/fromHexInto/name.js new file mode 100644 index 0000000000..7bf3d9761f --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: > + Uint8Array.fromHexInto.name is "fromHexInto". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.fromHexInto, 'name', { + value: 'fromHexInto', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/nonconstructor.js b/test/built-ins/Uint8Array/fromHexInto/nonconstructor.js new file mode 100644 index 0000000000..5b9ccf7966 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/nonconstructor.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: > + Uint8Array.fromHexInto is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.fromHexInto), "Uint8Array.fromHexInto is not a constructor"); + +assert.throws(TypeError, function() { + var target = new Uint8Array(10); + new Uint8Array.fromHexInto('', target); +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/results.js b/test/built-ins/Uint8Array/fromHexInto/results.js new file mode 100644 index 0000000000..41256e1baf --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/results.js @@ -0,0 +1,31 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Conversion of hex strings to Uint8Arrays +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var cases = [ + ["", []], + ["66", [102]], + ["666f", [102, 111]], + ["666F", [102, 111]], + ["666f6f", [102, 111, 111]], + ["666F6f", [102, 111, 111]], + ["666f6f62", [102, 111, 111, 98]], + ["666f6f6261", [102, 111, 111, 98, 97]], + ["666f6f626172", [102, 111, 111, 98, 97, 114]], +]; + +cases.forEach(function (pair) { + var allFF = [255, 255, 255, 255, 255, 255, 255, 255]; + var target = new Uint8Array(allFF); + var result = Uint8Array.fromHexInto(pair[0], target); + assert.sameValue(result.read, pair[0].length); + assert.sameValue(result.written, pair[1].length); + + var expected = pair[1].concat(allFF.slice(pair[1].length)) + assert.compareArray(target, expected, "decoding " + pair[0]); +}); diff --git a/test/built-ins/Uint8Array/fromHexInto/string-coercion.js b/test/built-ins/Uint8Array/fromHexInto/string-coercion.js new file mode 100644 index 0000000000..e7f08661ca --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/string-coercion.js @@ -0,0 +1,21 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto throws if its first argument is not a string +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called"); + } +}; + +assert.throws(TypeError, function() { + var target = new Uint8Array(10); + Uint8Array.fromHexInto(throwyToString, target); +}); +assert.sameValue(toStringCalls, 0); diff --git a/test/built-ins/Uint8Array/fromHexInto/subarray.js b/test/built-ins/Uint8Array/fromHexInto/subarray.js new file mode 100644 index 0000000000..92330afad2 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/subarray.js @@ -0,0 +1,17 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto takes into account the offset of the target Uint8Array +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +var base = new Uint8Array([255, 255, 255, 255, 255, 255, 255]); +var subarray = base.subarray(2, 5); + +var result = Uint8Array.fromHexInto('aabbcc', subarray); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 3); +assert.compareArray(subarray, [170, 187, 204]); +assert.compareArray(base, [255, 255, 170, 187, 204, 255, 255]); diff --git a/test/built-ins/Uint8Array/fromHexInto/target-size.js b/test/built-ins/Uint8Array/fromHexInto/target-size.js new file mode 100644 index 0000000000..b56a8a5905 --- /dev/null +++ b/test/built-ins/Uint8Array/fromHexInto/target-size.js @@ -0,0 +1,29 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.fromhexinto +description: Uint8Array.fromHexInto behavior when target buffer is small +includes: [compareArray.js] +features: [uint8array-base64] +---*/ + +// buffer too small +var target = new Uint8Array([255, 255]); +var result = Uint8Array.fromHexInto('aabbcc', target); +assert.sameValue(result.read, 4); +assert.sameValue(result.written, 2); +assert.compareArray(target, [170, 187]); + +// buffer exact +var target = new Uint8Array([255, 255, 255]); +var result = Uint8Array.fromHexInto('aabbcc', target); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 3); +assert.compareArray(target, [170, 187, 204]); + +// buffer too large +var target = new Uint8Array([255, 255, 255, 255]); +var result = Uint8Array.fromHexInto('aabbcc', target); +assert.sameValue(result.read, 6); +assert.sameValue(result.written, 3); +assert.compareArray(target, [170, 187, 204, 255]); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/alphabet.js b/test/built-ins/Uint8Array/prototype/toBase64/alphabet.js new file mode 100644 index 0000000000..64f4959a5e --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/alphabet.js @@ -0,0 +1,17 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: Conversion of Uint8Arrays to base64 strings exercising the alphabet option +features: [uint8array-base64] +---*/ + +assert.sameValue((new Uint8Array([199, 239, 242])).toBase64(), "x+/y"); + +assert.sameValue((new Uint8Array([199, 239, 242])).toBase64({ alphabet: 'base64' }), "x+/y"); + +assert.sameValue((new Uint8Array([199, 239, 242])).toBase64({ alphabet: 'base64url' }), "x-_y"); + +assert.throws(TypeError, function() { + (new Uint8Array([199, 239, 242])).toBase64({ alphabet: 'other' }); +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/descriptor.js b/test/built-ins/Uint8Array/prototype/toBase64/descriptor.js new file mode 100644 index 0000000000..6db2b911a7 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: > + Uint8Array.prototype.toBase64 has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype, 'toBase64', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/detached-buffer.js b/test/built-ins/Uint8Array/prototype/toBase64/detached-buffer.js new file mode 100644 index 0000000000..efdf072eaf --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/detached-buffer.js @@ -0,0 +1,39 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: Uint8Array.prototype.toBase64 checks for detachedness after side-effects are finished +includes: [detachArrayBuffer.js] +features: [uint8array-base64] +---*/ + +var array = new Uint8Array(2); +var getterCalls = 0; +var recevierDetachingOptions = {}; +Object.defineProperty(recevierDetachingOptions, "alphabet", { + get: function() { + getterCalls += 1; + $DETACHBUFFER(array.buffer); + return "base64"; + } +}); +assert.throws(TypeError, function() { + array.toBase64(recevierDetachingOptions); +}); +assert.sameValue(getterCalls, 1); + + +var detached = new Uint8Array(2); +$DETACHBUFFER(detached.buffer); +var getterCalls = 0; +var sideEffectingOptions = {}; +Object.defineProperty(sideEffectingOptions, "alphabet", { + get: function() { + getterCalls += 1; + return "base64"; + } +}); +assert.throws(TypeError, function() { + detached.toBase64(sideEffectingOptions); +}); +assert.sameValue(getterCalls, 1); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/length.js b/test/built-ins/Uint8Array/prototype/toBase64/length.js new file mode 100644 index 0000000000..a31b79151b --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: > + Uint8Array.prototype.toBase64.length is 0. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype.toBase64, 'length', { + value: 0, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/name.js b/test/built-ins/Uint8Array/prototype/toBase64/name.js new file mode 100644 index 0000000000..f13cb96927 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: > + Uint8Array.prototype.toBase64.name is "toBase64". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype.toBase64, 'name', { + value: 'toBase64', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/nonconstructor.js b/test/built-ins/Uint8Array/prototype/toBase64/nonconstructor.js new file mode 100644 index 0000000000..6d36216a9e --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/nonconstructor.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: > + Uint8Array.prototype.toBase64 is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.prototype.toBase64), "Uint8Array.prototype.toBase64 is not a constructor"); + +var uint8Array = new Uint8Array(8); +assert.throws(TypeError, function() { + new uint8Array.toBase64(); +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/option-coercion.js b/test/built-ins/Uint8Array/prototype/toBase64/option-coercion.js new file mode 100644 index 0000000000..c63deca571 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/option-coercion.js @@ -0,0 +1,43 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: Uint8Array.prototype.toBase64 triggers effects of the "alphabet" getter, but does not perform toString on the result +features: [uint8array-base64] +---*/ + +var toStringCalls = 0; +var throwyToString = { + toString: function() { + toStringCalls += 1; + throw new Test262Error("toString called on alphabet value"); + } +}; +assert.throws(TypeError, function() { + (new Uint8Array(2)).toBase64({ alphabet: throwyToString }); +}); +assert.sameValue(toStringCalls, 0); + +var alphabetAccesses = 0; +var base64UrlOptions = {}; +Object.defineProperty(base64UrlOptions, "alphabet", { + get: function() { + alphabetAccesses += 1; + return "base64url"; + } +}); +assert.sameValue((new Uint8Array([199, 239, 242])).toBase64(base64UrlOptions), "x-_y"); +assert.sameValue(alphabetAccesses, 1); + +// side-effects from the getter on the receiver are reflected in the result +var array = new Uint8Array([0]); +var recevierMutatingOptions = {}; +Object.defineProperty(recevierMutatingOptions, "alphabet", { + get: function() { + array[0] = 255; + return "base64"; + } +}); +var result = array.toBase64(recevierMutatingOptions); +assert.sameValue(result, "/w=="); +assert.sameValue(array[0], 255); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/receiver-not-uint8array.js b/test/built-ins/Uint8Array/prototype/toBase64/receiver-not-uint8array.js new file mode 100644 index 0000000000..e360b53da6 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/receiver-not-uint8array.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: Uint8Array.prototype.toBase64 throws if the receiver is not a Uint8Array +includes: [testTypedArray.js] +features: [uint8array-base64] +---*/ + +var toBase64 = Uint8Array.prototype.toBase64; + +var options = {}; +Object.defineProperty(options, "alphabet", { + get: function() { + throw new Test262Error("options.alphabet accessed despite incompatible receiver"); + } +}); + +testWithTypedArrayConstructors(function(TA) { + if (TA === Uint8Array) return; + var sample = new TA(2); + assert.throws(TypeError, function() { + Uint8Array.prototype.toBase64.call(sample, options); + }); +}); + +assert.throws(TypeError, function() { + Uint8Array.prototype.toBase64.call([], options); +}); + +assert.throws(TypeError, function() { + toBase64(options); +}); diff --git a/test/built-ins/Uint8Array/prototype/toBase64/results.js b/test/built-ins/Uint8Array/prototype/toBase64/results.js new file mode 100644 index 0000000000..d44e42d753 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toBase64/results.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tobase64 +description: Conversion of Uint8Arrays to base64 strings +features: [uint8array-base64] +---*/ + +// standard test vectors from https://datatracker.ietf.org/doc/html/rfc4648#section-10 +assert.sameValue((new Uint8Array([])).toBase64(), ""); +assert.sameValue((new Uint8Array([102])).toBase64(), "Zg=="); +assert.sameValue((new Uint8Array([102, 111])).toBase64(), "Zm8="); +assert.sameValue((new Uint8Array([102, 111, 111])).toBase64(), "Zm9v"); +assert.sameValue((new Uint8Array([102, 111, 111, 98])).toBase64(), "Zm9vYg=="); +assert.sameValue((new Uint8Array([102, 111, 111, 98, 97])).toBase64(), "Zm9vYmE="); +assert.sameValue((new Uint8Array([102, 111, 111, 98, 97, 114])).toBase64(), "Zm9vYmFy"); diff --git a/test/built-ins/Uint8Array/prototype/toHex/descriptor.js b/test/built-ins/Uint8Array/prototype/toHex/descriptor.js new file mode 100644 index 0000000000..16762d452b --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/descriptor.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: > + Uint8Array.prototype.toHex has default data property attributes. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype, 'toHex', { + enumerable: false, + writable: true, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toHex/detached-buffer.js b/test/built-ins/Uint8Array/prototype/toHex/detached-buffer.js new file mode 100644 index 0000000000..d98d62aa2e --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/detached-buffer.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: Uint8Array.prototype.toHex throws if called on a detached buffer +includes: [detachArrayBuffer.js] +features: [uint8array-base64] +---*/ + +var array = new Uint8Array(2); +$DETACHBUFFER(array.buffer); +assert.throws(TypeError, function() { + array.toHex(); +}); + diff --git a/test/built-ins/Uint8Array/prototype/toHex/length.js b/test/built-ins/Uint8Array/prototype/toHex/length.js new file mode 100644 index 0000000000..0cd4450c27 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/length.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: > + Uint8Array.prototype.toHex.length is 0. +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype.toHex, 'length', { + value: 0, + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toHex/name.js b/test/built-ins/Uint8Array/prototype/toHex/name.js new file mode 100644 index 0000000000..beca824e22 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/name.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: > + Uint8Array.prototype.toHex.name is "toHex". +includes: [propertyHelper.js] +features: [uint8array-base64] +---*/ + +verifyProperty(Uint8Array.prototype.toHex, 'name', { + value: 'toHex', + enumerable: false, + writable: false, + configurable: true +}); diff --git a/test/built-ins/Uint8Array/prototype/toHex/nonconstructor.js b/test/built-ins/Uint8Array/prototype/toHex/nonconstructor.js new file mode 100644 index 0000000000..7d4d9eac9b --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/nonconstructor.js @@ -0,0 +1,16 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: > + Uint8Array.prototype.toHex is not a constructor function. +includes: [isConstructor.js] +features: [uint8array-base64, Reflect.construct] +---*/ + +assert(!isConstructor(Uint8Array.prototype.toHex), "Uint8Array.prototype.toHex is not a constructor"); + +var uint8Array = new Uint8Array(8); +assert.throws(TypeError, function() { + new uint8Array.toHex(); +}); diff --git a/test/built-ins/Uint8Array/prototype/toHex/receiver-not-uint8array.js b/test/built-ins/Uint8Array/prototype/toHex/receiver-not-uint8array.js new file mode 100644 index 0000000000..c5d967a721 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/receiver-not-uint8array.js @@ -0,0 +1,26 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: Uint8Array.prototype.toHex throws if the receiver is not a Uint8Array +includes: [testTypedArray.js] +features: [uint8array-base64] +---*/ + +var toHex = Uint8Array.prototype.toHex; + +testWithTypedArrayConstructors(function(TA) { + if (TA === Uint8Array) return; + var sample = new TA(2); + assert.throws(TypeError, function() { + Uint8Array.prototype.toHex.call(sample); + }); +}); + +assert.throws(TypeError, function() { + Uint8Array.prototype.toHex.call([]); +}); + +assert.throws(TypeError, function() { + toHex(); +}); diff --git a/test/built-ins/Uint8Array/prototype/toHex/results.js b/test/built-ins/Uint8Array/prototype/toHex/results.js new file mode 100644 index 0000000000..108b973045 --- /dev/null +++ b/test/built-ins/Uint8Array/prototype/toHex/results.js @@ -0,0 +1,15 @@ +// Copyright (C) 2024 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-uint8array.prototype.tohex +description: Conversion of Uint8Arrays to hex strings +features: [uint8array-base64] +---*/ + +assert.sameValue((new Uint8Array([])).toHex(), ""); +assert.sameValue((new Uint8Array([102])).toHex(), "66"); +assert.sameValue((new Uint8Array([102, 111])).toHex(), "666f"); +assert.sameValue((new Uint8Array([102, 111, 111])).toHex(), "666f6f"); +assert.sameValue((new Uint8Array([102, 111, 111, 98])).toHex(), "666f6f62"); +assert.sameValue((new Uint8Array([102, 111, 111, 98, 97])).toHex(), "666f6f6261"); +assert.sameValue((new Uint8Array([102, 111, 111, 98, 97, 114])).toHex(), "666f6f626172");