[pull] main from nodejs:main

deps/googletest/include/gtest/gtest-printers.h

@@ -1173,15 +1173,12 @@ class [[nodiscard]] UniversalTersePrinter<const wchar_t*> {
     }
   }
 };
-#endif
 
 template <>
-class [[nodiscard]] UniversalTersePrinter<wchar_t*> {
- public:
-  static void Print(wchar_t* str, ::std::ostream* os) {
-    UniversalTersePrinter<const wchar_t*>::Print(str, os);
-  }
-};
+class [[nodiscard]] UniversalTersePrinter<wchar_t*>
+    : public UniversalTersePrinter<const wchar_t*> {};
+
+#endif  // GTEST_HAS_STD_WSTRING
 
 template <typename T>
 void UniversalTersePrint(const T& value, ::std::ostream* os) {

deps/googletest/include/gtest/internal/gtest-port.h

@@ -500,22 +500,71 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #endif  // defined(_MSC_VER) || defined(__BORLANDC__)
 #endif  // GTEST_HAS_EXCEPTIONS
 
-#ifndef GTEST_HAS_STD_WSTRING
-// The user didn't tell us whether ::std::wstring is available, so we need
-// to figure it out.
+// 1. Calculate default GTEST_HAS_STD_WSTRING values based on STL capabilities.
+#if defined(_MSVC_STL_VERSION)
+// Microsoft's STL implementation always supports ::std::wstring.
+#define GTEST_HAS_STD_WSTRING_DEFAULT 1
+
+#elif defined(_LIBCPP_VERSION)
+// Modern libc++ always defines _LIBCPP_HAS_WIDE_CHARACTERS; its value
+// determines whether wide characters are supported.
+// Older libc++ omits a definition for _LIBCPP_HAS_NO_WIDE_CHARACTERS when wide
+// characters are supported.
+#if (defined(_LIBCPP_HAS_WIDE_CHARACTERS) && !_LIBCPP_HAS_WIDE_CHARACTERS) || \
+    defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#define GTEST_HAS_STD_WSTRING_DEFAULT 0
+#else
+#define GTEST_HAS_STD_WSTRING_DEFAULT 1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#define GTEST_HAS_STD_WSTRING_DEFAULT 1
+#else
+#define GTEST_HAS_STD_WSTRING_DEFAULT 0
+#endif
+
+#else
+// Unknown standard library implementation; fall back looking at the OS.
+//
+// Always let the user override the defaults in this case; they might have more
+// information about what's supported than we do.
+#if defined(GTEST_OS_LINUX_ANDROID)
+// Android started supporting std::wstring with API Level 21 (Lollipop).
+#define GTEST_HAS_STD_WSTRING_DEFAULT (__ANDROID_API__ >= 21)
+// The following platforms are known not to support ::std::wstring; assume it's
+// supported on all others.
+//
 // Cygwin 1.7 and below doesn't support ::std::wstring.
-// Solaris' libc++ doesn't support it either.  Android has
-// no support for it at least as recent as Froyo (2.2).
-#if (!(defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_CYGWIN) || \
-       defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_HAIKU) ||        \
-       defined(GTEST_OS_ESP32) || defined(GTEST_OS_ESP8266) ||        \
-       defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) ||          \
-       defined(GTEST_OS_NXP_QN9090) || defined(GTEST_OS_NRF52)))
-#define GTEST_HAS_STD_WSTRING 1
+// Solaris' libc++ doesn't support it either.
+#elif defined(GTEST_OS_CYGWIN) || defined(GTEST_OS_SOLARIS) || \
+    defined(GTEST_OS_HAIKU) || defined(GTEST_OS_ESP32) ||      \
+    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||   \
+    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||  \
+    defined(GTEST_OS_NRF52)
+#define GTEST_HAS_STD_WSTRING_DEFAULT 0
 #else
-#define GTEST_HAS_STD_WSTRING 0
+#define GTEST_HAS_STD_WSTRING_DEFAULT 1
+#endif
+#endif
+
+// 2. Validate explicit user overrides (if user passed -DGTEST_HAS_*=1) against
+//    what the standard library implementation tells us it supports.
+#if defined(GTEST_HAS_STD_WSTRING) && GTEST_HAS_STD_WSTRING
+#if defined(_LIBCPP_VERSION) &&                                                \
+    ((defined(_LIBCPP_HAS_WIDE_CHARACTERS) && !_LIBCPP_HAS_WIDE_CHARACTERS) || \
+     defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS))
+#error Cannot explicitly enable GTEST_HAS_STD_WSTRING without libc++ wide character support.
+#elif defined(__GLIBCXX__) && \
+    !(defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T)
+#error Cannot explicitly enable GTEST_HAS_STD_WSTRING without libstdc++ wide character support.
+#endif
+#endif
+
+// 3. Set final values if not explicitly overridden by user
+#if !defined(GTEST_HAS_STD_WSTRING)
+#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_WSTRING_DEFAULT
 #endif
-#endif  // GTEST_HAS_STD_WSTRING
 
 #ifndef GTEST_HAS_FILE_SYSTEM
 // Most platforms support a file system.

deps/googletest/src/gtest-printers.cc

@@ -50,6 +50,7 @@
 #include <iomanip>
 #include <ios>
 #include <ostream>  // NOLINT
+#include <string>
 #include <string_view>
 #include <type_traits>
 
@@ -422,14 +423,36 @@ void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
 
 namespace {
 
+template <typename Char>
+size_t GetLength(const Char* s) {
+  return std::char_traits<Char>::length(s);
+}
+
+#if !GTEST_HAS_STD_WSTRING
+
+// If GTEST_HAS_STD_WSTRING is unset because the standard library has disabled
+// wide character support, std::char_traits<wchar_t> won't be defined, which
+// will cause a compile error, even if user code never actually could print a
+// wide cstring. In that case, instead use `wcslen` directly.
+//
+// If `libc` _also_ lacks wide character support, this (and a bunch of other
+// calls to wc functions) will fail to link, but only if user code actually
+// uses them.
+template <>
+size_t GetLength<wchar_t>(const wchar_t* s) {
+  return wcslen(s);
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 void PrintCStringTo(const Char* s, ostream* os) {
   if (s == nullptr) {
     *os << "NULL";
   } else {
     *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+    PrintCharsAsStringTo(s, GetLength(s), os);
   }
 }
 

test/sequential/test-performance-eventloopdelay.js

@@ -9,6 +9,18 @@ const {
 } = require('perf_hooks');
 const { sleep } = require('internal/util');
 
+function runEventLoopIterations(iterations, callback) {
+  let remaining = iterations;
+  function tick() {
+    if (--remaining > 0) {
+      setImmediate(tick);
+    } else {
+      callback();
+    }
+  }
+  setImmediate(tick);
+}
+
 {
   const histogram = monitorEventLoopDelay();
   assert(histogram);
@@ -125,12 +137,16 @@ const { sleep } = require('internal/util');
 }
 
 {
+  const iterations = 10;
   const histogram = monitorEventLoopDelay({ samplePerIteration: true });
   histogram.enable();
-  setTimeout(common.mustCall(() => {
+  runEventLoopIterations(iterations, common.mustCall(() => {
     histogram.disable();
-    assert(histogram.count > 0,
-           `Expected samples to be recorded, got count=${histogram.count}`);
+    assert(
+      histogram.count >= iterations - 1,
+      `Expected at least ${iterations - 1} samples for ${iterations} iterations, ` +
+      `got ${histogram.count}`
+    );
     assert(histogram.min > 0);
     assert(histogram.max > 0);
     assert(histogram.mean > 0);
@@ -146,7 +162,7 @@ const { sleep } = require('internal/util');
     assert(Number.isNaN(histogram.mean));
     assert(Number.isNaN(histogram.stddev));
     assert.strictEqual(histogram.percentiles.size, 1);
-  }), common.platformTimeout(20));
+  }));
 }
 
 {
@@ -158,65 +174,40 @@ const { sleep } = require('internal/util');
   assert.strictEqual(histogram.disable(), false); // Already disabled, no-op
   // Re-enabling after disable should work
   assert.strictEqual(histogram.enable(), true);
-  setTimeout(common.mustCall(() => {
+  runEventLoopIterations(10, common.mustCall(() => {
     histogram.disable();
     assert(histogram.count > 0,
            `Expected samples after re-enable, got count=${histogram.count}`);
-  }), common.platformTimeout(20));
+  }));
 }
 
 {
   // Verify that samplePerIteration records exactly one sample per event loop iteration.
-  const N = 10;
+  // It should do so independently of the timer resolution used by the legacy
+  // monitorEventLoopDelay path.
+  const iterations = 10;
   const histogram = monitorEventLoopDelay({ samplePerIteration: true });
-  histogram.enable();
-
-  let iterations = 0;
-  const verify = common.mustCall(() => {
-    histogram.disable();
-    assert(
-      histogram.count >= N - 1,
-      `Expected at least ${N - 1} samples for ${N} iterations, got ${histogram.count}`
-    );
-  });
-
-  function tick() {
-    if (++iterations < N) {
-      setImmediate(tick);
-    } else {
-      verify();
-    }
-  }
-  setImmediate(tick);
-}
-
-{
-  // samplePerIteration should sample per event loop iteration, independent of
-  // the timer resolution used by the legacy monitorEventLoopDelay path.
-  const N = 10;
-  const histogram = monitorEventLoopDelay({
+  const largeResolutionHistogram = monitorEventLoopDelay({
     samplePerIteration: true,
     resolution: 60 * 1000,
   });
   histogram.enable();
+  largeResolutionHistogram.enable();
 
-  let iterations = 0;
-  const verify = common.mustCall(() => {
+  runEventLoopIterations(iterations, common.mustCall(() => {
     histogram.disable();
+    largeResolutionHistogram.disable();
     assert(
-      histogram.count >= N - 1,
-      `Expected samples despite large resolution, got count=${histogram.count}`
+      histogram.count >= iterations - 1,
+      `Expected at least ${iterations - 1} samples for ${iterations} iterations, ` +
+      `got ${histogram.count}`
     );
-  });
-
-  function tick() {
-    if (++iterations < N) {
-      setImmediate(tick);
-    } else {
-      verify();
-    }
-  }
-  setImmediate(tick);
+    assert(
+      largeResolutionHistogram.count >= iterations - 1,
+      `Expected samples despite large resolution, ` +
+      `got count=${largeResolutionHistogram.count}`
+    );
+  }));
 }
 
 // Make sure that the histogram instances can be garbage-collected without

tools/icu/icu-generic.gyp

@@ -208,6 +208,7 @@
                   'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.<(icu_asm_ext)' ],
                   'action': [ '<(PRODUCT_DIR)/genccode<(EXECUTABLE_SUFFIX)',
                               '<@(icu_asm_opts)', # -o
+                              '-c', '<(target_arch)',
                               '-d', '<(SHARED_INTERMEDIATE_DIR)/',
                               '-n', 'icudata',
                               '-e', 'icusmdt<(icu_ver_major)',