diff --git a/deps/googletest/include/gtest/gtest-printers.h b/deps/googletest/include/gtest/gtest-printers.h index 315ce0a51016..69c9fec3ca95 100644 --- a/deps/googletest/include/gtest/gtest-printers.h +++ b/deps/googletest/include/gtest/gtest-printers.h @@ -1173,15 +1173,12 @@ class [[nodiscard]] UniversalTersePrinter { } } }; -#endif template <> -class [[nodiscard]] UniversalTersePrinter { - public: - static void Print(wchar_t* str, ::std::ostream* os) { - UniversalTersePrinter::Print(str, os); - } -}; +class [[nodiscard]] UniversalTersePrinter + : public UniversalTersePrinter {}; + +#endif // GTEST_HAS_STD_WSTRING template void UniversalTersePrint(const T& value, ::std::ostream* os) { diff --git a/deps/googletest/include/gtest/internal/gtest-port.h b/deps/googletest/include/gtest/internal/gtest-port.h index 92e6591d2cec..051228553449 100644 --- a/deps/googletest/include/gtest/internal/gtest-port.h +++ b/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. diff --git a/deps/googletest/src/gtest-printers.cc b/deps/googletest/src/gtest-printers.cc index 7c0ecc6ad1c9..975ebb829876 100644 --- a/deps/googletest/src/gtest-printers.cc +++ b/deps/googletest/src/gtest-printers.cc @@ -50,6 +50,7 @@ #include #include #include // NOLINT +#include #include #include @@ -422,6 +423,28 @@ void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) { namespace { +template +size_t GetLength(const Char* s) { + return std::char_traits::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 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(const wchar_t* s) { + return wcslen(s); +} + +#endif // GTEST_HAS_STD_WSTRING + // Prints a null-terminated C-style string to the ostream. template void PrintCStringTo(const Char* s, ostream* os) { @@ -429,7 +452,7 @@ void PrintCStringTo(const Char* s, ostream* os) { *os << "NULL"; } else { *os << ImplicitCast_(s) << " pointing to "; - PrintCharsAsStringTo(s, std::char_traits::length(s), os); + PrintCharsAsStringTo(s, GetLength(s), os); } } diff --git a/test/sequential/test-performance-eventloopdelay.js b/test/sequential/test-performance-eventloopdelay.js index ddd33372ec5e..ede729514937 100644 --- a/test/sequential/test-performance-eventloopdelay.js +++ b/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 diff --git a/tools/icu/icu-generic.gyp b/tools/icu/icu-generic.gyp index f49b4ddba74a..c4e8c6fbb9f8 100644 --- a/tools/icu/icu-generic.gyp +++ b/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)',