Prepare for v1.18.0 (#5055)

MODULE.bazel

@@ -32,7 +32,7 @@
 
 module(
     name = "googletest",
-    version = "head",
+    version = "1.18.0",
     compatibility_level = 1,
 )
 

googlemock/include/gmock/gmock-actions.h

@@ -940,7 +940,7 @@ class [[nodiscard]] ReturnAction final {
                 std::is_convertible<R, U>,        //
                 std::is_move_constructible<U>>::value>::type>
   operator OnceAction<U(Args...)>() && {  // NOLINT
-    return OnceImpl<U>(std::move(value_));
+    return Impl<U>(std::move(value_));
   }
 
   template <typename U, typename... Args,
@@ -959,6 +959,13 @@ class [[nodiscard]] ReturnAction final {
   template <typename U>
   class Impl final {
    public:
+    // The constructor used when the return value is allowed to move from the
+    // input value (i.e. we are converting to OnceAction).
+    explicit Impl(R&& input_value)
+        : state_(new State(std::move(input_value))) {}
+
+    // The constructor used when the return value is not allowed to move from
+    // the input value (i.e. we are converting to Action).
     explicit Impl(const R& input_value) : state_(new State(input_value)) {}
 
     U operator()() && { return std::move(state_->value); }
@@ -989,6 +996,18 @@ class [[nodiscard]] ReturnAction final {
             // explicit constructor from R.
             value(ImplicitCast_<U>(internal::as_const(input_value))) {}
 
+      // As above, but for the case where we're moving from the ReturnAction
+      // object because it's being used as a OnceAction.
+      explicit State(R&& input_value_in)
+          : input_value(std::move(input_value_in)),
+            // For the same reason as above we make an implicit conversion to U
+            // before initializing the value.
+            //
+            // Unlike above we provide the input value as an rvalue to the
+            // implicit conversion because this is a OnceAction: it's fine if it
+            // wants to consume the input value.
+            value(ImplicitCast_<U>(std::move(input_value))) {}
+
       // A copy of the value originally provided by the user. We retain this in
       // addition to the value of the mock function's result type below in case
       // the latter is a reference-like type. See the std::string_view example
@@ -1066,23 +1085,6 @@ class [[nodiscard]] ReturnAction final {
     const std::shared_ptr<State> state_;
   };
 
-  // Implements the Return(x) action for a mock function that returns type U,
-  // but is only executed at most once. This allows us to store the original
-  // value and move construct the return value type on the first (and only)
-  // call.
-  template <typename U>
-  class OnceImpl final {
-   public:
-    explicit OnceImpl(R&& input_value)
-        : input_value_(new R(std::move(input_value))) {}
-
-    U operator()() && { return std::move(*input_value_); }
-
-   private:
-    // Move the input value to the heap and make it copyable.
-    const std::shared_ptr<R> input_value_;
-  };
-
   R value_;
 };
 

googletest/include/gtest/gtest-printers.h

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

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

@@ -500,71 +500,22 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #endif  // defined(_MSC_VER) || defined(__BORLANDC__)
 #endif  // GTEST_HAS_EXCEPTIONS
 
-// 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.
-//
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
 // Cygwin 1.7 and below doesn't support ::std::wstring.
-// 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
+// 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
 #else
-#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
+#define GTEST_HAS_STD_WSTRING 0
 #endif
+#endif  // GTEST_HAS_STD_WSTRING
 
 #ifndef GTEST_HAS_FILE_SYSTEM
 // Most platforms support a file system.

googletest/src/gtest-printers.cc

@@ -50,7 +50,6 @@
 #include <iomanip>
 #include <ios>
 #include <ostream>  // NOLINT
-#include <string>
 #include <string_view>
 #include <type_traits>
 
@@ -423,28 +422,6 @@ 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) {
@@ -452,7 +429,7 @@ void PrintCStringTo(const Char* s, ostream* os) {
     *os << "NULL";
   } else {
     *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, GetLength(s), os);
+    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
   }
 }