tools: add WPT updater

Author: Mert Can Altin

.github/workflows/update-wpt.yml

@@ -0,0 +1,45 @@
+name: Update WPT
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run once a week at 12:00 AM UTC on Sunday.
+    - cron: 0 0 * * *
+
+jobs:
+  update-wpt:
+    name: Update WPT
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332  # v4.1.7
+        with:
+          persist-credentials: false
+          sparse-checkout: |
+            !test/fixtures/wpt
+      - name: Clone WPT Repository
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332  # v4.1.7
+        with:
+          repository: web-platform-tests/wpt
+          path: test/fixtures/wpt
+          sparse_checkout: common/ eventsource/ fetch/ interfaces/ mimesniff/ resources/ service-workers/ storage/ websockets/ xhr/ LICENSE.md
+          persist-credentials: false
+      - name: Move WPT Files
+        run: |
+            rm -rf test/fixtures/wpt/.git
+            echo "NEW_VERSION=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+      - name: Create Pull Request
+        uses: gr2m/create-or-update-pull-request-action@86ec1766034c8173518f61d2075cc2a173fb8c97  # v1.9.4
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }}
+        with:
+          author: Node.js GitHub Bot <[email protected]>
+          body: This is an automated update of the WPT to ${{ env.NEW_VERSION }}.
+          branch: actions/update-wpt  # Custom branch *just* for this Action.
+          commit-message: 'test: update WPT to ${{ env.NEW_VERSION }}'
+          labels: test
+          title: 'test: update WPT to ${{ env.NEW_VERSION }}'
+          update-pull-request-title-and-body: true

benchmark/buffers/buffer-transcode.js

@@ -2050,7 +2050,7 @@ added: v22.3.0
 
 > Stability: 1.0 - Early development
 
-* `specifier` {string|URL} A string identifying the module to mock.
+* `specifier` {string} A string identifying the module to mock.
 * `options` {Object} Optional configuration options for the mock module. The
   following properties are supported:
   * `cache` {boolean} If `false`, each call to `require()` or `import()`

doc/api/test.md

@@ -371,10 +371,7 @@ function stripTypeScriptTypes(source, filename) {
     const base64SourceMap = Buffer.from(map).toString('base64');
     return `${code}\n\n//# sourceMappingURL=data:application/json;base64,${base64SourceMap}`;
   }
-  // Source map is not necessary in strip-only mode. However, to map the source
-  // file in debuggers to the original TypeScript source, add a sourceURL magic
-  // comment to hint that it is a generated source.
-  return `${code}\n\n//# sourceURL=${filename}`;
+  return code;
 }
 
 function isUnderNodeModules(filename) {

lib/internal/modules/helpers.js

@@ -340,8 +340,8 @@ class TestCoverage {
       const { data, lineLengths } = sourceMapCache[url];
       let offset = 0;
       const executedLines = ArrayPrototypeMap(lineLengths, (length, i) => {
-        const coverageLine = new CoverageLine(i + 1, offset, null, length + 1);
-        offset += length + 1;
+        const coverageLine = new CoverageLine(i + 1, offset, null, length);
+        offset += length;
         return coverageLine;
       });
       if (data.sourcesContent != null) {

lib/internal/test_runner/coverage.js

@@ -34,7 +34,7 @@ const {
 } = require('internal/errors');
 const esmLoader = require('internal/modules/esm/loader');
 const { getOptionValue } = require('internal/options');
-const { fileURLToPath, toPathIfFileURL, URL, isURL } = require('internal/url');
+const { fileURLToPath, toPathIfFileURL, URL } = require('internal/url');
 const {
   emitExperimentalWarning,
   getStructuredStack,
@@ -49,6 +49,7 @@ const {
   validateInteger,
   validateObject,
   validateOneOf,
+  validateString,
 } = require('internal/validators');
 const { MockTimers } = require('internal/test_runner/mock/mock_timers');
 const { strictEqual, notStrictEqual } = require('assert');
@@ -487,11 +488,7 @@ class MockTracker {
 
   module(specifier, options = kEmptyObject) {
     emitExperimentalWarning('Module mocking');
-    if (typeof specifier !== 'string') {
-      if (!isURL(specifier))
-        throw new ERR_INVALID_ARG_TYPE('specifier', ['string', 'URL'], specifier);
-      specifier = `${specifier}`;
-    }
+    validateString(specifier, 'specifier');
     validateObject(options, 'options');
     debug('module mock entry, specifier = "%s", options = %o', specifier, options);
 

lib/internal/test_runner/mock/mock.js

@@ -42,7 +42,6 @@
 
 #include "node_i18n.h"
 #include "node_external_reference.h"
-#include "simdutf.h"
 
 #if defined(NODE_HAVE_I18N_SUPPORT)
 
@@ -148,6 +147,7 @@ MaybeLocal<Object> Transcode(Environment* env,
                              const char* source,
                              const size_t source_length,
                              UErrorCode* status) {
+  *status = U_ZERO_ERROR;
   MaybeLocal<Object> ret;
   MaybeStackBuffer<char> result;
   Converter to(toEncoding);
@@ -170,21 +170,22 @@ MaybeLocal<Object> Transcode(Environment* env,
   return ret;
 }
 
-MaybeLocal<Object> TranscodeLatin1ToUcs2(Environment* env,
-                                         const char* fromEncoding,
-                                         const char* toEncoding,
-                                         const char* source,
-                                         const size_t source_length,
-                                         UErrorCode* status) {
+MaybeLocal<Object> TranscodeToUcs2(Environment* env,
+                                   const char* fromEncoding,
+                                   const char* toEncoding,
+                                   const char* source,
+                                   const size_t source_length,
+                                   UErrorCode* status) {
+  *status = U_ZERO_ERROR;
+  MaybeLocal<Object> ret;
   MaybeStackBuffer<UChar> destbuf(source_length);
-  auto actual_length =
-      simdutf::convert_latin1_to_utf16le(source, source_length, destbuf.out());
-  if (actual_length == 0) {
-    *status = U_INVALID_CHAR_FOUND;
-    return {};
-  }
-
-  return Buffer::New(env, &destbuf);
+  Converter from(fromEncoding);
+  const size_t length_in_chars = source_length * sizeof(UChar);
+  ucnv_toUChars(from.conv(), *destbuf, length_in_chars,
+                source, source_length, status);
+  if (U_SUCCESS(*status))
+    ret = ToBufferEndian(env, &destbuf);
+  return ret;
 }
 
 MaybeLocal<Object> TranscodeFromUcs2(Environment* env,
@@ -193,11 +194,13 @@ MaybeLocal<Object> TranscodeFromUcs2(Environment* env,
                                      const char* source,
                                      const size_t source_length,
                                      UErrorCode* status) {
+  *status = U_ZERO_ERROR;
   MaybeStackBuffer<UChar> sourcebuf;
   MaybeLocal<Object> ret;
   Converter to(toEncoding);
 
-  std::string sub(to.min_char_size(), '?');
+  size_t sublen = ucnv_getMinCharSize(to.conv());
+  std::string sub(sublen, '?');
   to.set_subst_chars(sub.c_str());
 
   const size_t length_in_chars = source_length / sizeof(UChar);
@@ -218,18 +221,26 @@ MaybeLocal<Object> TranscodeUcs2FromUtf8(Environment* env,
                                          const char* source,
                                          const size_t source_length,
                                          UErrorCode* status) {
-  size_t expected_utf16_length =
-      simdutf::utf16_length_from_utf8(source, source_length);
-  MaybeStackBuffer<UChar> destbuf(expected_utf16_length);
-  auto actual_length =
-      simdutf::convert_utf8_to_utf16le(source, source_length, destbuf.out());
-
-  if (actual_length == 0) {
-    *status = U_INVALID_CHAR_FOUND;
-    return {};
+  *status = U_ZERO_ERROR;
+  MaybeStackBuffer<UChar> destbuf;
+  int32_t result_length;
+  u_strFromUTF8(*destbuf, destbuf.capacity(), &result_length,
+                source, source_length, status);
+  MaybeLocal<Object> ret;
+  if (U_SUCCESS(*status)) {
+    destbuf.SetLength(result_length);
+    ret = ToBufferEndian(env, &destbuf);
+  } else if (*status == U_BUFFER_OVERFLOW_ERROR) {
+    *status = U_ZERO_ERROR;
+    destbuf.AllocateSufficientStorage(result_length);
+    u_strFromUTF8(*destbuf, result_length, &result_length,
+                  source, source_length, status);
+    if (U_SUCCESS(*status)) {
+      destbuf.SetLength(result_length);
+      ret = ToBufferEndian(env, &destbuf);
+    }
   }
-
-  return Buffer::New(env, &destbuf);
+  return ret;
 }
 
 MaybeLocal<Object> TranscodeUtf8FromUcs2(Environment* env,
@@ -238,25 +249,32 @@ MaybeLocal<Object> TranscodeUtf8FromUcs2(Environment* env,
                                          const char* source,
                                          const size_t source_length,
                                          UErrorCode* status) {
+  *status = U_ZERO_ERROR;
+  MaybeLocal<Object> ret;
   const size_t length_in_chars = source_length / sizeof(UChar);
-  size_t expected_utf8_length = simdutf::utf8_length_from_utf16le(
-      reinterpret_cast<const char16_t*>(source), length_in_chars);
-
-  MaybeStackBuffer<char> destbuf(expected_utf8_length);
-  auto actual_length = simdutf::convert_utf16le_to_utf8(
-      reinterpret_cast<const char16_t*>(source),
-      length_in_chars,
-      destbuf.out());
-
-  if (actual_length == 0) {
-    *status = U_INVALID_CHAR_FOUND;
-    return {};
+  int32_t result_length;
+  MaybeStackBuffer<UChar> sourcebuf;
+  MaybeStackBuffer<char> destbuf;
+  CopySourceBuffer(&sourcebuf, source, source_length, length_in_chars);
+  u_strToUTF8(*destbuf, destbuf.capacity(), &result_length,
+              *sourcebuf, length_in_chars, status);
+  if (U_SUCCESS(*status)) {
+    destbuf.SetLength(result_length);
+    ret = ToBufferEndian(env, &destbuf);
+  } else if (*status == U_BUFFER_OVERFLOW_ERROR) {
+    *status = U_ZERO_ERROR;
+    destbuf.AllocateSufficientStorage(result_length);
+    u_strToUTF8(*destbuf, result_length, &result_length, *sourcebuf,
+                length_in_chars, status);
+    if (U_SUCCESS(*status)) {
+      destbuf.SetLength(result_length);
+      ret = ToBufferEndian(env, &destbuf);
+    }
   }
-
-  return Buffer::New(env, &destbuf);
+  return ret;
 }
 
-constexpr const char* EncodingName(const enum encoding encoding) {
+const char* EncodingName(const enum encoding encoding) {
   switch (encoding) {
     case ASCII: return "us-ascii";
     case LATIN1: return "iso8859-1";
@@ -266,7 +284,7 @@ constexpr const char* EncodingName(const enum encoding encoding) {
   }
 }
 
-constexpr bool SupportedEncoding(const enum encoding encoding) {
+bool SupportedEncoding(const enum encoding encoding) {
   switch (encoding) {
     case ASCII:
     case LATIN1:
@@ -291,7 +309,8 @@ void Transcode(const FunctionCallbackInfo<Value>&args) {
     switch (fromEncoding) {
       case ASCII:
       case LATIN1:
-        if (toEncoding == UCS2) tfn = &TranscodeLatin1ToUcs2;
+        if (toEncoding == UCS2)
+          tfn = &TranscodeToUcs2;
         break;
       case UTF8:
         if (toEncoding == UCS2)

src/node_i18n.cc

@@ -271,14 +271,6 @@ class InspectorSession {
         `break on ${url}:${line}`);
   }
 
-  waitForPauseOnStart() {
-    return this
-      .waitForNotification(
-        (notification) =>
-          notification.method === 'Debugger.paused' && notification.params.reason === 'Break on start',
-        'break on start');
-  }
-
   pausedDetails() {
     return this._pausedDetails;
   }