deps: update googletest to 49495eacfdbda3f4b6ba219923fedbb2e3f99376

PR-URL: #65317
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>

Author: nodejs-github-bot

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }
 

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:
-staticvoidPrint(wchar_t* str, ::std::ostream* os) {
- UniversalTersePrinter<constwchar_t*>::Print(str, os);
- }
-};
+class[[nodiscard]] UniversalTersePrinter<wchar_t*>
+ : public UniversalTersePrinter<constwchar_t*> {};
+
+#endif// GTEST_HAS_STD_WSTRING
 
 template <typename T>
 voidUniversalTersePrint(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.
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+
+#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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#endif
+
+#elif defined(__GLIBCXX__)
+#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#else
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
+#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).
+#defineGTEST_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)))
-#defineGTEST_HAS_STD_WSTRING1
+// 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)
+#defineGTEST_HAS_STD_WSTRING_DEFAULT0
 #else
-#defineGTEST_HAS_STD_WSTRING0
+#defineGTEST_HAS_STD_WSTRING_DEFAULT1
+#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)
+#defineGTEST_HAS_STD_WSTRINGGTEST_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_tGetLength(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>(constwchar_t* s) {
+returnwcslen(s);
+}
+
+#endif// GTEST_HAS_STD_WSTRING
+
 // Prints a null-terminated C-style string to the ostream.
 template <typename Char>
 voidPrintCStringTo(const Char* s, ostream* os) {
 if (s == nullptr) {
  *os << "NULL";
  } else {
  *os << ImplicitCast_<constvoid*>(s) << " pointing to ";
-PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+PrintCharsAsStringTo(s, GetLength(s), os);
  }
 }