code merge, cleanups

googletest/include/gtest/gtest-death-test.h

@@ -102,7 +102,7 @@ GTEST_API_ bool InDeathTestChild();
 //   On POSIX-compliant systems (*nix), we use the <regex.h> library,
 //   which uses the POSIX extended regex syntax.
 //
-//   On other platforms (e.g. Windows), we only support a simple regex
+//   On other platforms (e.g. Windows or Mac), we only support a simple regex
 //   syntax implemented as part of Google Test.  This limited
 //   implementation should be enough most of the time when writing
 //   death tests; though it lacks many features you can find in PCRE

googletest/test/gtest-param-test2_test.cc

@@ -33,7 +33,6 @@
 // Google Test work.
 
 #include "gtest/gtest.h"
-
 #include "test/gtest-param-test_test.h"
 
 using ::testing::Values;

googletest/test/gtest-param-test_test.cc

@@ -41,8 +41,8 @@
 # include <sstream>
 # include <string>
 # include <vector>
-# include "src/gtest-internal-inl.h"  // for UnitTestOptions
 
+# include "src/gtest-internal-inl.h"  // for UnitTestOptions
 # include "test/gtest-param-test_test.h"
 
 using ::std::vector;
@@ -536,6 +536,48 @@ TEST(CombineTest, CombineWithMaxNumberOfParameters) {
   VerifyGenerator(gen, expected_values);
 }
 
+class NonDefaultConstructAssignString {
+ public:
+  NonDefaultConstructAssignString(const std::string& str) : str_(str) {}
+
+  const std::string& str() const { return str_; }
+
+ private:
+  std::string str_;
+
+  // Not default constructible
+  NonDefaultConstructAssignString();
+  // Not assignable
+  void operator=(const NonDefaultConstructAssignString&);
+};
+
+TEST(CombineTest, NonDefaultConstructAssign) {
+  const ParamGenerator<tuple<int, NonDefaultConstructAssignString>> gen =
+      Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
+                                   NonDefaultConstructAssignString("B")));
+
+  ParamGenerator<tuple<int, NonDefaultConstructAssignString>>::iterator it =
+      gen.begin();
+
+  EXPECT_EQ(0, std::get<0>(*it));
+  EXPECT_EQ("A", std::get<1>(*it).str());
+  ++it;
+
+  EXPECT_EQ(0, std::get<0>(*it));
+  EXPECT_EQ("B", std::get<1>(*it).str());
+  ++it;
+
+  EXPECT_EQ(1, std::get<0>(*it));
+  EXPECT_EQ("A", std::get<1>(*it).str());
+  ++it;
+
+  EXPECT_EQ(1, std::get<0>(*it));
+  EXPECT_EQ("B", std::get<1>(*it).str());
+  ++it;
+
+  EXPECT_TRUE(it == gen.end());
+}
+
 # endif  // GTEST_HAS_COMBINE
 
 // Tests that an generator produces correct sequence after being
@@ -851,8 +893,8 @@ TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
 INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
                         CustomLambdaNamingTest,
                         Values(std::string("LambdaName")),
-                        [](const ::testing::TestParamInfo<std::string>& tpinfo) {
+                        [](const ::testing::TestParamInfo<std::string>& info) {
-                          return tpinfo.param;
+                          return info.param;
                         });
 
 #endif  // GTEST_LANG_CXX11
@@ -1019,6 +1061,7 @@ TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
 
 INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
 
+
 int main(int argc, char **argv) {
   // Used in TestGenerationTest test case.
   AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());

googletest/test/gtest-printers_test.cc

@@ -197,8 +197,7 @@ inline ::std::ostream& operator<<(::std::ostream& os,
 // boost::filesystem::path.
 class PathLike {
  public:
-  struct iterator
+  struct iterator {
-  {
     typedef PathLike value_type;
   };
   typedef iterator const_iterator;
@@ -208,9 +207,7 @@ class PathLike {
   iterator begin() const { return iterator(); }
   iterator end() const { return iterator(); }
 
-  friend 
+  friend ::std::ostream& operator<<(::std::ostream& os, const PathLike&) {
-  ::std::ostream& operator<<(::std::ostream& os, const PathLike&)
-  {
     return os << "Streamable-PathLike";
   }
 };
@@ -250,9 +247,9 @@ using ::testing::internal::string;
 #if GTEST_HAS_UNORDERED_MAP_
 
 #define GTEST_HAS_HASH_MAP_ 1
-template<class Key, class T>
+template <class Key, class T>
 using hash_map = ::std::unordered_map<Key, T>;
-template<class Key, class T>
+template <class Key, class T>
 using hash_multimap = ::std::unordered_multimap<Key, T>;
 
 #elif GTEST_HAS_HASH_MAP_
@@ -270,9 +267,9 @@ using ::stdext::hash_multimap;
 #if GTEST_HAS_UNORDERED_SET_
 
 #define GTEST_HAS_HASH_SET_ 1
-template<class Key>
+template <class Key>
 using hash_set = ::std::unordered_set<Key>;
-template<class Key>
+template <class Key>
 using hash_multiset = ::std::unordered_multiset<Key>;
 
 #elif GTEST_HAS_HASH_SET_
@@ -1092,7 +1089,7 @@ TEST(PrintTr1TupleTest, VariousSizes) {
   ::std::tr1::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
                     testing::internal::Int64, float, double, const char*, void*,
                     std::string>
-      t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str, 
+      t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,  // NOLINT
           ImplicitCast_<void*>(NULL), "10");
   EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
             " pointing to \"8\", NULL, \"10\")",
@@ -1152,7 +1149,7 @@ TEST(PrintStdTupleTest, VariousSizes) {
   ::std::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
                testing::internal::Int64, float, double, const char*, void*,
                std::string>
-      t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,
+      t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,  // NOLINT
           ImplicitCast_<void*>(NULL), "10");
   EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
             " pointing to \"8\", NULL, \"10\")",

googletest/test/production.h

@@ -29,7 +29,7 @@
 //
 // Author: wan@google.com (Zhanyong Wan)
 //
-// This is part of the unit test for include/gtest/gtest_prod.h.
+// This is part of the unit test for gtest_prod.h.
 
 #ifndef GTEST_TEST_PRODUCTION_H_
 #define GTEST_TEST_PRODUCTION_H_