test: prepare test-whatwg-encoding-* to be ported to WPT if possible

test/parallel/test-whatwg-encoding-api-basics.js

@@ -0,0 +1,74 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-basics.html
+// TODO(joyeecheung): replace this with WPT
+
+const common = require('../common');
+
+if (!common.hasIntl)
+  common.skip('missing Intl');
+
+const assert = require('assert');
+
+function testDecodeSample(encoding, string, bytes) {
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+// `z` (ASCII U+007A), cent (Latin-1 U+00A2), CJK water (BMP U+6C34),
+// G-Clef (non-BMP U+1D11E), PUA (BMP U+F8FF), PUA (non-BMP U+10FFFD)
+// byte-swapped BOM (non-character U+FFFE)
+const sample = 'z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE';
+
+{
+  const encoding = 'utf-8';
+  const string = sample;
+  const bytes = [
+    0x7A, 0xC2, 0xA2, 0xE6, 0xB0, 0xB4,
+    0xF0, 0x9D, 0x84, 0x9E, 0xEF, 0xA3,
+    0xBF, 0xF4, 0x8F, 0xBF, 0xBD, 0xEF,
+    0xBF, 0xBE
+  ];
+  const encoded = new TextEncoder().encode(string);
+  assert.deepStrictEqual([].slice.call(encoded), bytes);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+testDecodeSample(
+  'utf-16le',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+  ]
+);
+
+testDecodeSample(
+  'utf-16be',
+  sample,
+  [
+    0x00, 0x7A, 0x00, 0xA2, 0x6C, 0x34,
+    0xD8, 0x34, 0xDD, 0x1E, 0xF8, 0xFF,
+    0xDB, 0xFF, 0xDF, 0xFD, 0xFF, 0xFE
+  ]
+);
+
+testDecodeSample(
+  'utf-16',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+  ]
+);

test/parallel/test-whatwg-encoding-custom-api-basics.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-basics.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+function testDecodeSample(encoding, string, bytes) {
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+// `z` (ASCII U+007A), cent (Latin-1 U+00A2), CJK water (BMP U+6C34),
+// G-Clef (non-BMP U+1D11E), PUA (BMP U+F8FF), PUA (non-BMP U+10FFFD)
+// byte-swapped BOM (non-character U+FFFE)
+const sample = 'z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE';
+
+{
+  const encoding = 'utf-8';
+  const string = sample;
+  const bytes = [
+    0x7A, 0xC2, 0xA2, 0xE6, 0xB0, 0xB4,
+    0xF0, 0x9D, 0x84, 0x9E, 0xEF, 0xA3,
+    0xBF, 0xF4, 0x8F, 0xBF, 0xBD, 0xEF,
+    0xBF, 0xBE
+  ];
+  const encoded = new TextEncoder().encode(string);
+  assert.deepStrictEqual([].slice.call(encoded), bytes);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes)),
+    string);
+  assert.strictEqual(
+    new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
+    string);
+}
+
+testDecodeSample(
+  'utf-16le',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+  ]
+);
+
+testDecodeSample(
+  'utf-16',
+  sample,
+  [
+    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
+    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+  ]
+);

test/parallel/test-whatwg-encoding-fatal-streaming.js → test/parallel/test-whatwg-encoding-custom-fatal-streaming.js

@@ -1,6 +1,7 @@
 'use strict';
 
 // From: https://github.com/w3c/web-platform-tests/blob/d74324b53c/encoding/textdecoder-fatal-streaming.html
+// With the twist that we specifically test for Node.js error codes
 
 const common = require('../common');
 
@@ -28,6 +29,7 @@ const assert = require('assert');
       }
     );
 
+    // TODO(joyeecheung): remove this when WPT is ported
     assert.strictEqual(
       new TextDecoder(testCase.encoding).decode(data),
       '\uFFFD'
@@ -40,6 +42,7 @@ const assert = require('assert');
   const odd = new Uint8Array([0x00]);
   const even = new Uint8Array([0x00, 0x00]);
 
+  // TODO(joyeecheung): remove this when WPT is ported
   assert.strictEqual(decoder.decode(odd, { stream: true }), '');
   assert.strictEqual(decoder.decode(odd), '\u0000');
 
@@ -67,6 +70,7 @@ const assert = require('assert');
     }
   );
 
+  // TODO(joyeecheung): remove this when WPT is ported
   assert.strictEqual(decoder.decode(even, { stream: true }), '\u0000');
   assert.strictEqual(decoder.decode(even), '\u0000');
 }

test/parallel/test-whatwg-encoding-internals.js → test/parallel/test-whatwg-encoding-custom-internals.js

@@ -1,6 +1,8 @@
 // Flags: --expose-internals
 'use strict';
 
+// This tests internal mapping of the Node.js encoding implementation
+
 require('../common');
 
 const assert = require('assert');

test/parallel/test-whatwg-encoding-textencoder.js → test/parallel/test-whatwg-encoding-custom-interop.js

@@ -1,4 +1,8 @@
 // Flags: --expose-internals
+
+// This tests interoperability between TextEncoder and TextDecoder with
+// Node.js util.inspect and Buffer APIs
+
 'use strict';
 
 const common = require('../common');

test/parallel/test-whatwg-encoding-custom-textdecoder-api-invalid-label.js

@@ -0,0 +1,40 @@
+'use strict';
+// From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-invalid-label.html
+// With the twist that we specifically test for Node.js error codes
+
+const common = require('../common');
+
+[
+  'utf-8',
+  'unicode-1-1-utf-8',
+  'utf8',
+  'utf-16be',
+  'utf-16le',
+  'utf-16'
+].forEach((i) => {
+  ['\u0000', '\u000b', '\u00a0', '\u2028', '\u2029'].forEach((ws) => {
+    common.expectsError(
+      () => new TextDecoder(`${ws}${i}`),
+      {
+        code: 'ERR_ENCODING_NOT_SUPPORTED',
+        type: RangeError
+      }
+    );
+
+    common.expectsError(
+      () => new TextDecoder(`${i}${ws}`),
+      {
+        code: 'ERR_ENCODING_NOT_SUPPORTED',
+        type: RangeError
+      }
+    );
+
+    common.expectsError(
+      () => new TextDecoder(`${ws}${i}${ws}`),
+      {
+        code: 'ERR_ENCODING_NOT_SUPPORTED',
+        type: RangeError
+      }
+    );
+  });
+});

test/parallel/test-whatwg-encoding-textdecoder-fatal.js → test/parallel/test-whatwg-encoding-custom-textdecoder-fatal.js

@@ -1,6 +1,7 @@
 'use strict';
 
 // From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-fatal.html
+// With the twist that we specifically test for Node.js error codes
 
 const common = require('../common');
 
@@ -82,21 +83,10 @@ bad.forEach((t) => {
   );
 });
 
+// TODO(joyeecheung): remove this when WPT is ported
 {
   assert('fatal' in new TextDecoder());
   assert.strictEqual(typeof new TextDecoder().fatal, 'boolean');
   assert(!new TextDecoder().fatal);
   assert(new TextDecoder('utf-8', { fatal: true }).fatal);
 }
-
-{
-  const notArrayBufferViewExamples = [false, {}, 1, '', new Error()];
-  notArrayBufferViewExamples.forEach((invalidInputType) => {
-    common.expectsError(() => {
-      new TextDecoder(undefined, null).decode(invalidInputType);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
-  });
-}

test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/7f567fa29c/encoding/textdecoder-ignorebom.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+const cases = [
+  {
+    encoding: 'utf-8',
+    bytes: [0xEF, 0xBB, 0xBF, 0x61, 0x62, 0x63]
+  },
+  {
+    encoding: 'utf-16le',
+    bytes: [0xFF, 0xFE, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00]
+  }
+];
+
+cases.forEach((testCase) => {
+  const BOM = '\uFEFF';
+  let decoder = new TextDecoder(testCase.encoding, { ignoreBOM: true });
+  const bytes = new Uint8Array(testCase.bytes);
+  assert.strictEqual(decoder.decode(bytes), `${BOM}abc`);
+  decoder = new TextDecoder(testCase.encoding, { ignoreBOM: false });
+  assert.strictEqual(decoder.decode(bytes), 'abc');
+  decoder = new TextDecoder(testCase.encoding);
+  assert.strictEqual(decoder.decode(bytes), 'abc');
+});

test/parallel/test-whatwg-encoding-custom-textdecoder-invalid-arg.js

@@ -0,0 +1,18 @@
+'use strict';
+
+// This tests that ERR_INVALID_ARG_TYPE are thrown when
+// invalid arguments are passed to TextDecoder.
+
+const common = require('../common');
+
+{
+  const notArrayBufferViewExamples = [false, {}, 1, '', new Error()];
+  notArrayBufferViewExamples.forEach((invalidInputType) => {
+    common.expectsError(() => {
+      new TextDecoder(undefined, null).decode(invalidInputType);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    });
+  });
+}

test/parallel/test-whatwg-encoding-custom-textdecoder-streaming.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// From: https://github.com/w3c/web-platform-tests/blob/fa9436d12c/encoding/textdecoder-streaming.html
+// This is the part that can be run without ICU
+
+require('../common');
+
+const assert = require('assert');
+
+const string =
+  '\x00123ABCabc\x80\xFF\u0100\u1000\uFFFD\uD800\uDC00\uDBFF\uDFFF';
+const octets = {
+  'utf-8': [
+    0x00, 0x31, 0x32, 0x33, 0x41, 0x42, 0x43, 0x61, 0x62, 0x63, 0xc2, 0x80,
+    0xc3, 0xbf, 0xc4, 0x80, 0xe1, 0x80, 0x80, 0xef, 0xbf, 0xbd, 0xf0, 0x90,
+    0x80, 0x80, 0xf4, 0x8f, 0xbf, 0xbf],
+  'utf-16le': [
+    0x00, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x41, 0x00, 0x42, 0x00,
+    0x43, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x80, 0x00, 0xFF, 0x00,
+    0x00, 0x01, 0x00, 0x10, 0xFD, 0xFF, 0x00, 0xD8, 0x00, 0xDC, 0xFF, 0xDB,
+    0xFF, 0xDF]
+};
+
+Object.keys(octets).forEach((encoding) => {
+  for (let len = 1; len <= 5; ++len) {
+    const encoded = octets[encoding];
+    const decoder = new TextDecoder(encoding);
+    let out = '';
+    for (let i = 0; i < encoded.length; i += len) {
+      const sub = [];
+      for (let j = i; j < encoded.length && j < i + len; ++j)
+        sub.push(encoded[j]);
+      out += decoder.decode(new Uint8Array(sub), { stream: true });
+    }
+    out += decoder.decode();
+    assert.strictEqual(out, string);
+  }
+});

test/parallel/test-whatwg-encoding-textdecoder-utf16-surrogates.js → test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js

@@ -1,6 +1,7 @@
 'use strict';
 
 // From: https://github.com/w3c/web-platform-tests/blob/39a67e2fff/encoding/textdecoder-utf16-surrogates.html
+// With the twist that we specifically test for Node.js error codes
 
 const common = require('../common');
 
@@ -43,7 +44,7 @@ const bad = [
 ];
 
 bad.forEach((t) => {
-
+  // TODO(joyeecheung): remove this when WPT is ported
   assert.strictEqual(
     new TextDecoder(t.encoding).decode(new Uint8Array(t.input)),
     t.expected);