修改googletest版本

3rdparty/googletest-1.13.0/googletest/test/googletest-message-test.cc → 3rdparty/googletest-release-1.12.1/googletest/test/googletest-message-test.cc

@@ -30,9 +30,6 @@
 //
 // Tests for the Message class.
 
-#include <sstream>
-#include <string>
-
 #include "gtest/gtest-message.h"
 #include "gtest/gtest.h"
 

3rdparty/googletest-1.13.0/googletest/test/googletest-options-test.cc → 3rdparty/googletest-release-1.12.1/googletest/test/googletest-options-test.cc

@@ -36,8 +36,6 @@
 // make-files on Windows and other platforms. Do not #include this file
 // anywhere else!
 
-#include <string>
-
 #include "gtest/gtest.h"
 
 #if GTEST_OS_WINDOWS_MOBILE

3rdparty/googletest-1.13.0/googletest/test/googletest-param-test-test.cc → 3rdparty/googletest-release-1.12.1/googletest/test/googletest-param-test-test.cc

@@ -40,7 +40,6 @@
 #include <set>
 #include <sstream>
 #include <string>
-#include <tuple>
 #include <vector>
 
 #include "gtest/gtest.h"
@@ -52,7 +51,6 @@ using ::std::vector;
 using ::testing::AddGlobalTestEnvironment;
 using ::testing::Bool;
 using ::testing::Combine;
-using ::testing::ConvertGenerator;
 using ::testing::Message;
 using ::testing::Range;
 using ::testing::TestWithParam;
@@ -404,7 +402,7 @@ TEST(BoolTest, BoolWorks) {
 TEST(CombineTest, CombineWithTwoParameters) {
   const char* foo = "foo";
   const char* bar = "bar";
-  const ParamGenerator<std::tuple<const char*, int>> gen =
+  const ParamGenerator<std::tuple<const char*, int> > gen =
       Combine(Values(foo, bar), Values(3, 4));
 
   std::tuple<const char*, int> expected_values[] = {
@@ -415,7 +413,7 @@ TEST(CombineTest, CombineWithTwoParameters) {
 
 // Tests that Combine() with three parameters generates the expected sequence.
 TEST(CombineTest, CombineWithThreeParameters) {
-  const ParamGenerator<std::tuple<int, int, int>> gen =
+  const ParamGenerator<std::tuple<int, int, int> > gen =
       Combine(Values(0, 1), Values(3, 4), Values(5, 6));
   std::tuple<int, int, int> expected_values[] = {
       std::make_tuple(0, 3, 5), std::make_tuple(0, 3, 6),
@@ -429,7 +427,7 @@ TEST(CombineTest, CombineWithThreeParameters) {
 // sequence generates a sequence with the number of elements equal to the
 // number of elements in the sequence generated by the second parameter.
 TEST(CombineTest, CombineWithFirstParameterSingleValue) {
-  const ParamGenerator<std::tuple<int, int>> gen =
+  const ParamGenerator<std::tuple<int, int> > gen =
       Combine(Values(42), Values(0, 1));
 
   std::tuple<int, int> expected_values[] = {std::make_tuple(42, 0),
@@ -441,7 +439,7 @@ TEST(CombineTest, CombineWithFirstParameterSingleValue) {
 // sequence generates a sequence with the number of elements equal to the
 // number of elements in the sequence generated by the first parameter.
 TEST(CombineTest, CombineWithSecondParameterSingleValue) {
-  const ParamGenerator<std::tuple<int, int>> gen =
+  const ParamGenerator<std::tuple<int, int> > gen =
       Combine(Values(0, 1), Values(42));
 
   std::tuple<int, int> expected_values[] = {std::make_tuple(0, 42),
@@ -452,7 +450,7 @@ TEST(CombineTest, CombineWithSecondParameterSingleValue) {
 // Tests that when the first parameter produces an empty sequence,
 // Combine() produces an empty sequence, too.
 TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
-  const ParamGenerator<std::tuple<int, int>> gen =
+  const ParamGenerator<std::tuple<int, int> > gen =
       Combine(Range(0, 0), Values(0, 1));
   VerifyGeneratorIsEmpty(gen);
 }
@@ -460,7 +458,7 @@ TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
 // Tests that when the second parameter produces an empty sequence,
 // Combine() produces an empty sequence, too.
 TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
-  const ParamGenerator<std::tuple<int, int>> gen =
+  const ParamGenerator<std::tuple<int, int> > gen =
       Combine(Values(0, 1), Range(1, 1));
   VerifyGeneratorIsEmpty(gen);
 }
@@ -471,7 +469,7 @@ TEST(CombineTest, CombineWithMaxNumberOfParameters) {
   const char* foo = "foo";
   const char* bar = "bar";
   const ParamGenerator<
-      std::tuple<const char*, int, int, int, int, int, int, int, int, int>>
+      std::tuple<const char*, int, int, int, int, int, int, int, int, int> >
       gen =
           Combine(Values(foo, bar), Values(1), Values(2), Values(3), Values(4),
                   Values(5), Values(6), Values(7), Values(8), Values(9));
@@ -499,11 +497,11 @@ class NonDefaultConstructAssignString {
 };
 
 TEST(CombineTest, NonDefaultConstructAssign) {
-  const ParamGenerator<std::tuple<int, NonDefaultConstructAssignString>> gen =
+  const ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> > gen =
       Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
                                    NonDefaultConstructAssignString("B")));
 
-  ParamGenerator<std::tuple<int, NonDefaultConstructAssignString>>::iterator
+  ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> >::iterator
       it = gen.begin();
 
   EXPECT_EQ(0, std::get<0>(*it));
@@ -525,64 +523,6 @@ TEST(CombineTest, NonDefaultConstructAssign) {
   EXPECT_TRUE(it == gen.end());
 }
 
-template <typename T>
-class ConstructFromT {
- public:
-  explicit ConstructFromT(const T& t) : t_(t) {}
-  template <typename... Args,
-            typename std::enable_if<sizeof...(Args) != 1, int>::type = 0>
-  ConstructFromT(Args&&... args) : t_(std::forward<Args>(args)...) {}
-
-  bool operator==(const ConstructFromT& other) const { return other.t_ == t_; }
-
-  const T& get() const { return t_; }
-
- private:
-  T t_;
-};
-
-TEST(ConvertTest, CombineWithTwoParameters) {
-  const char* foo = "foo";
-  const char* bar = "bar";
-  const ParamGenerator<ConstructFromT<std::tuple<const char*, int>>> gen =
-      ConvertGenerator<std::tuple<const char*, int>>(
-          Combine(Values(foo, bar), Values(3, 4)));
-
-  ConstructFromT<std::tuple<const char*, int>> expected_values[] = {
-      {foo, 3}, {foo, 4}, {bar, 3}, {bar, 4}};
-  VerifyGenerator(gen, expected_values);
-}
-
-TEST(ConvertTest, NonDefaultConstructAssign) {
-  const ParamGenerator<
-      ConstructFromT<std::tuple<int, NonDefaultConstructAssignString>>>
-      gen = ConvertGenerator<std::tuple<int, NonDefaultConstructAssignString>>(
-          Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
-                                       NonDefaultConstructAssignString("B"))));
-
-  ParamGenerator<ConstructFromT<
-      std::tuple<int, NonDefaultConstructAssignString>>>::iterator it =
-      gen.begin();
-
-  EXPECT_EQ(0, std::get<0>(it->get()));
-  EXPECT_EQ("A", std::get<1>(it->get()).str());
-  ++it;
-
-  EXPECT_EQ(0, std::get<0>(it->get()));
-  EXPECT_EQ("B", std::get<1>(it->get()).str());
-  ++it;
-
-  EXPECT_EQ(1, std::get<0>(it->get()));
-  EXPECT_EQ("A", std::get<1>(it->get()).str());
-  ++it;
-
-  EXPECT_EQ(1, std::get<0>(it->get()));
-  EXPECT_EQ("B", std::get<1>(it->get()).str());
-  ++it;
-
-  EXPECT_TRUE(it == gen.end());
-}
-
 // Tests that an generator produces correct sequence after being
 // assigned from another generator.
 TEST(ParamGeneratorTest, AssignmentWorks) {
@@ -881,7 +821,7 @@ TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),
 TEST(MacroNameing, LookupNames) {
   std::set<std::string> know_suite_names, know_test_names;
 
-  const auto& ins = testing::UnitTest::GetInstance();
+  auto ins = testing::UnitTest::GetInstance();
   int ts = 0;
   while (const testing::TestSuite* suite = ins->GetTestSuite(ts++)) {
     know_suite_names.insert(suite->name());
@@ -957,7 +897,7 @@ INSTANTIATE_TEST_SUITE_P(CustomParamNameLambda, CustomLambdaNamingTest,
                          });
 
 TEST(CustomNamingTest, CheckNameRegistry) {
-  const auto& unit_test = ::testing::UnitTest::GetInstance();
+  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
   std::set<std::string> test_names;
   for (int suite_num = 0; suite_num < unit_test->total_test_suite_count();
        ++suite_num) {

3rdparty/googletest-1.13.0/googletest/test/googletest-port-test.cc → 3rdparty/googletest-release-1.12.1/googletest/test/googletest-port-test.cc

@@ -39,7 +39,6 @@
 #include <chrono>  // NOLINT
 #include <list>
 #include <memory>
-#include <string>
 #include <thread>   // NOLINT
 #include <utility>  // For std::pair and std::make_pair.
 #include <vector>

3rdparty/googletest-1.13.0/googletest/test/googletest-printers-test.cc → 3rdparty/googletest-release-1.12.1/googletest/test/googletest-printers-test.cc

@@ -37,7 +37,6 @@
 #include <cstring>
 #include <deque>
 #include <forward_list>
-#include <functional>
 #include <limits>
 #include <list>
 #include <map>
@@ -194,11 +193,6 @@ OutputStream& operator<<(OutputStream& os,
   return os;
 }
 
-struct StreamableInLocal {};
-void operator<<(::std::ostream& os, const StreamableInLocal& /* x */) {
-  os << "StreamableInLocal";
-}
-
 // A user-defined streamable but recursively-defined container type in
 // a user namespace, it mimics therefore std::filesystem::path or
 // boost::filesystem::path.
@@ -458,15 +452,7 @@ TEST(PrintBuiltInTypeTest, Int128) {
 
 // Floating-points.
 TEST(PrintBuiltInTypeTest, FloatingPoints) {
-  // float (32-bit precision)
-  EXPECT_EQ("1.5", Print(1.5f));
-
-  EXPECT_EQ("1.0999999",  Print(1.09999990f));
-  EXPECT_EQ("1.1",        Print(1.10000002f));
-  EXPECT_EQ("1.10000014", Print(1.10000014f));
-  EXPECT_EQ("9e+09",      Print(9e9f));
-
-  // double
+  EXPECT_EQ("1.5", Print(1.5f));   // float
   EXPECT_EQ("-2.5", Print(-2.5));  // double
 }
 
@@ -1618,23 +1604,6 @@ TEST(PrintToStringTest, ContainsNonLatin) {
                           "\n    As Text: \"From ä — ẑ\"");
 }
 
-TEST(PrintToStringTest, PrintStreamableInLocal) {
-  EXPECT_STREQ("StreamableInLocal",
-               PrintToString(foo::StreamableInLocal()).c_str());
-}
-
-TEST(PrintToStringTest, PrintReferenceToStreamableInLocal) {
-  foo::StreamableInLocal s;
-  std::reference_wrapper<foo::StreamableInLocal> r(s);
-  EXPECT_STREQ("StreamableInLocal", PrintToString(r).c_str());
-}
-
-TEST(PrintToStringTest, PrintReferenceToStreamableInGlobal) {
-  StreamableInGlobal s;
-  std::reference_wrapper<StreamableInGlobal> r(s);
-  EXPECT_STREQ("StreamableInGlobal", PrintToString(r).c_str());
-}
-
 TEST(IsValidUTF8Test, IllFormedUTF8) {
   // The following test strings are ill-formed UTF-8 and are printed
   // as hex only (or ASCII, in case of ASCII bytes) because IsValidUTF8() is