Merge 5062aa991f6257d8fdccb1dfeea676bca7f7c971 into a0f06a70e3da7afa88da9527c43951bca1f7cef2

Fixes: #2066
PiperOrigin-RevId: 955981465
Change-Id: I6b34dc2e634d4b727a50fb3e21e5d8e25c39a13b

googlemock/test/gmock-matchers-comparisons_test.cc

@@ -272,6 +272,40 @@ TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
   EXPECT_TRUE(m2.Matches("cats"));
   EXPECT_FALSE(m2.Matches("dogs"));
 }
+
+// Tests that a StringView object can be implicitly converted to a
+// Matcher<std::string> or Matcher<const std::string&>. This is the symmetric
+// counterpart of CanBeImplicitlyConstructedFromString above; without these
+// constructors, a StringView falls through to a polymorphic Eq matcher that
+// stores the view by value and dangles past the constructing call.
+TEST(StringMatcherTest, CanBeImplicitlyConstructedFromStringView) {
+  Matcher<std::string> m1 = internal::StringView("cats");
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const std::string&> m2 = internal::StringView("cats");
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that the matcher copies the string data and is safe to use after the
+// underlying buffer the StringView was constructed from is destroyed.
+TEST(StringMatcherTest, StringViewCtorIsLifetimeSafe) {
+  Matcher<std::string> m1;
+  Matcher<const std::string&> m2;
+  {
+    std::string buffer = "cats";
+    m1 = internal::StringView(buffer);
+    m2 = internal::StringView(buffer);
+    // Mutate buffer and let it go out of scope to ensure the matcher does not
+    // alias |buffer|'s storage.
+    buffer = "dogs";
+  }
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 
 // Tests that a std::reference_wrapper<std::string> object can be implicitly

googlemock/test/gmock_stress_test.cc

@@ -30,6 +30,8 @@
 // Tests that Google Mock constructs can be used in a large number of
 // threads concurrently.
 
+#include <iterator>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -188,7 +190,7 @@ TEST(StressTest, CanUseGMockWithThreads) {
       &TestPartiallyOrderedExpectationsWithThreads,
   };
 
-  const int kRoutines = sizeof(test_routines) / sizeof(test_routines[0]);
+  const int kRoutines = std::size(test_routines);
   const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines;
   const int kTestThreads = kCopiesOfEachRoutine * kRoutines;
   ThreadWithParam<Dummy>* threads[kTestThreads] = {};

googletest/include/gtest/gtest-matchers.h

@@ -517,6 +517,13 @@ Matcher<const std::string&> : public internal::MatcherBase<const std::string&> {
 
   // Allows the user to write "foo" instead of Eq("foo") sometimes.
   Matcher(const char* s);  // NOLINT
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Copies into a std::string so the matcher owns its data and does not alias
+  // a (possibly temporary) buffer in the caller.
+  Matcher(internal::StringView s);  // NOLINT
+#endif
 };
 
 template <>
@@ -541,6 +548,13 @@ Matcher<std::string> : public internal::MatcherBase<std::string> {
 
   // Allows the user to write "foo" instead of Eq("foo") sometimes.
   Matcher(const char* s);  // NOLINT
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Copies into a std::string so the matcher owns its data and does not alias
+  // a (possibly temporary) buffer in the caller.
+  Matcher(internal::StringView s);  // NOLINT
+#endif
 };
 
 #if GTEST_INTERNAL_HAS_STRING_VIEW

googletest/include/gtest/gtest-printers.h

@@ -945,13 +945,13 @@ template <typename T>
 class [[nodiscard]] UniversalPrinter<std::optional<T>> {
  public:
   static void Print(const std::optional<T>& value, ::std::ostream* os) {
-    *os << '(';
     if (!value) {
-      *os << "nullopt";
+      UniversalPrint(std::nullopt, os);
     } else {
+      *os << '(';
       UniversalPrint(*value, os);
+      *os << ')';
     }
-    *os << ')';
   }
 };
 
@@ -961,27 +961,38 @@ class [[nodiscard]] UniversalPrinter<std::nullopt_t> {
   static void Print(std::nullopt_t, ::std::ostream* os) { *os << "(nullopt)"; }
 };
 
+struct UniversalPrinterVisitor {
+  template <typename T>
+  void operator()(const T& arg) const {
+    *os << "'" << GetTypeName<T>() << "(index = " << index << ")' with value ";
+    UniversalPrint(arg, os);
+  }
+  ::std::ostream* os;
+  std::size_t index;
+};
+
 // Printer for std::variant
 template <typename... T>
 class [[nodiscard]] UniversalPrinter<std::variant<T...>> {
  public:
   static void Print(const std::variant<T...>& value, ::std::ostream* os) {
-    *os << '(';
+    if (value.valueless_by_exception()) {
-    std::visit(Visitor{os, value.index()}, value);
+      *os << "(valueless)";
-    *os << ')';
+    } else {
-  }
+      *os << '(';
-
+      std::visit(UniversalPrinterVisitor{os, value.index()}, value);
- private:
+      *os << ')';
-  struct Visitor {
-    template <typename U>
-    void operator()(const U& u) const {
-      *os << "'" << GetTypeName<U>() << "(index = " << index
-          << ")' with value ";
-      UniversalPrint(u, os);
     }
-    ::std::ostream* os;
+  }
-    std::size_t index;
+};
-  };
+
+// Printer for std::monostate
+template <>
+class [[nodiscard]] UniversalPrinter<std::monostate> {
+ public:
+  static void Print(std::monostate, ::std::ostream* os) {
+    *os << "(monostate)";
+  }
 };
 
 // UniversalPrintArray(begin, len, os) prints an array of 'len'

googletest/samples/sample2_unittest.cc

@@ -39,6 +39,8 @@
 
 #include "sample2.h"
 
+#include <iterator>
+
 #include "gtest/gtest.h"
 namespace {
 // In this example, we test the MyString class (a simple string).
@@ -78,7 +80,7 @@ const char kHelloString[] = "Hello, world!";
 TEST(MyString, ConstructorFromCString) {
   const MyString s(kHelloString);
   EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-  EXPECT_EQ(sizeof(kHelloString) / sizeof(kHelloString[0]) - 1, s.Length());
+  EXPECT_EQ(std::size(kHelloString) - 1, s.Length());
 }
 
 // Tests the copy c'tor.

googletest/src/gtest-internal-inl.h

@@ -587,7 +587,7 @@ class GTEST_API_ UnitTestImpl {
   // total_test_suite_count() - 1. If i is not in that range, returns NULL.
   const TestSuite* GetTestSuite(int i) const {
     const int index = GetElementOr(test_suite_indices_, i, -1);
-    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
   }
 
   //  Legacy API is deprecated but still available

googletest/src/gtest-matchers.cc

@@ -93,6 +93,18 @@ Matcher<internal::StringView>::Matcher(const char* s) {
 Matcher<internal::StringView>::Matcher(internal::StringView s) {
   *this = Eq(std::string(s));
 }
+
+// Constructs a matcher that matches a const std::string& whose value is
+// equal to s. Copies into a std::string so the matcher owns its data.
+Matcher<const std::string&>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a std::string whose value is equal to s.
+// Copies into a std::string so the matcher owns its data.
+Matcher<std::string>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 
 }  // namespace testing

googletest/test/googletest-listener-test.cc

@@ -32,6 +32,7 @@
 // This file verifies Google Test event listeners receive events at the
 // right times.
 
+#include <iterator>
 #include <string>
 #include <vector>
 
@@ -498,8 +499,7 @@ int main(int argc, char** argv) {
                                          "1st.OnTestProgramEnd"};
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
-  VerifyResults(events, expected_events,
+  VerifyResults(events, expected_events, std::size(expected_events));
-                sizeof(expected_events) / sizeof(expected_events[0]));
 
   // We need to check manually for ad hoc test failures that happen after
   // RUN_ALL_TESTS finishes.

googletest/test/googletest-output-test_.cc

@@ -36,6 +36,7 @@
 #include <stdlib.h>
 
 #include <algorithm>
+#include <iterator>
 #include <string>
 
 #include "gtest/gtest-spi.h"
@@ -149,7 +150,7 @@ TEST(LoggingTest, InterleavingLoggingAndAssertions) {
   static const int a[4] = {3, 9, 2, 6};
 
   printf("(expecting 2 failures on (3) >= (a[i]))\n");
-  for (int i = 0; i < static_cast<int>(sizeof(a) / sizeof(*a)); i++) {
+  for (int i = 0; i < static_cast<int>(std::size(a)); i++) {
     printf("i == %d\n", i);
     EXPECT_GE(3, a[i]);
   }

googletest/test/googletest-param-test-test.cc

@@ -39,6 +39,7 @@
 #include <cstdint>
 #include <functional>
 #include <iostream>
+#include <iterator>
 #include <list>
 #include <set>
 #include <sstream>
@@ -737,10 +738,7 @@ const int test_generation_params[] = {36, 42, 72};
 
 class TestGenerationTest : public TestWithParam<int> {
  public:
-  enum {
+  enum { PARAMETER_COUNT = std::size(test_generation_params) };
-    PARAMETER_COUNT =
-        sizeof(test_generation_params) / sizeof(test_generation_params[0])
-  };
 
   typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
 

googletest/test/googletest-printers-test.cc

@@ -39,6 +39,7 @@
 #include <deque>
 #include <forward_list>
 #include <functional>
+#include <iterator>
 #include <limits>
 #include <list>
 #include <map>
@@ -1784,7 +1785,7 @@ TEST(IsValidUTF8Test, IllFormedUTF8) {
       // too.
       {"\xEE\x80\x80", "\"\\xEE\\x80\\x80\"\n    As Text: \"\""}};
 
-  for (int i = 0; i < int(sizeof(kTestdata) / sizeof(kTestdata[0])); ++i) {
+  for (int i = 0; i < int(std::size(kTestdata)); ++i) {
     EXPECT_PRINT_TO_STRING_(kTestdata[i][0], kTestdata[i][1]);
   }
 }
@@ -2029,6 +2030,26 @@ TEST(PrintOneofTest, Basic) {
       PrintToString(Type(NonPrintable{})));
 }
 
+TEST(PrintVariantTest, Monostate) {
+  EXPECT_EQ("(monostate)", PrintToString(std::monostate()));
+
+#if GTEST_HAS_EXCEPTIONS
+  struct ThrowOnMove {
+    ThrowOnMove() = default;
+    ThrowOnMove(ThrowOnMove&& other) { *this = std::move(other); }
+    ThrowOnMove& operator=(ThrowOnMove&&) {
+      (void)std::vector<bool>().at(0);
+      return *this;
+    }
+  };
+  std::variant<std::monostate, ThrowOnMove> v = std::monostate();
+  EXPECT_EQ("('std::monostate(index = 0)' with value (monostate))",
+            PrintToString(v));
+  EXPECT_THROW(v = ThrowOnMove(), std::out_of_range);
+  EXPECT_EQ("(valueless)", PrintToString(v));
+#endif
+}
+
 #if GTEST_INTERNAL_HAS_COMPARE_LIB
 TEST(PrintOrderingTest, Basic) {
   EXPECT_EQ("(less)", PrintToString(std::strong_ordering::less));

googletest/test/gtest_unittest.cc

@@ -33,6 +33,8 @@
 
 #include "gtest/gtest.h"
 
+#include <iterator>
+
 // Verifies that the command line flag variables can be accessed in
 // code once "gtest.h" has been #included.
 // Do not move it after other gtest #includes.
@@ -5853,9 +5855,8 @@ class ParseFlagsTest : public Test {
   // to specify the array sizes.
 
 #define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
-  TestParsingFlags(sizeof(argv1) / sizeof(*argv1) - 1, argv1,                \
+  TestParsingFlags(std::size(argv1) - 1, argv1, std::size(argv2) - 1, argv2, \
-                   sizeof(argv2) / sizeof(*argv2) - 1, argv2, expected,      \
+                   expected, should_print_help)
-                   should_print_help)
 };
 
 // Tests parsing an empty command line.