Upgrade gtest to r267 and gmock to r173.

testing/gmock/test/gmock-printers_test.cc

 // Copyright 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 136 matching lines @@
 using ::std::map;
 using ::std::multimap;
 using ::std::multiset;
 using ::std::pair;
 using ::std::set;
 using ::std::tr1::make_tuple;
 using ::std::tr1::tuple;
 using ::std::vector;
 using ::testing::ElementsAre;
 using ::testing::StartsWith;
+using ::testing::internal::NativeArray;
 using ::testing::internal::Strings;
 using ::testing::internal::UniversalTersePrint;
+using ::testing::internal::UniversalPrint;
 using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
 using ::testing::internal::UniversalPrinter;
+using ::testing::internal::kReference;
 using ::testing::internal::string;
 
 #if GTEST_OS_WINDOWS
 // MSVC defines the following classes in the ::stdext namespace while
 // gcc defines them in the :: namespace.  Note that they are not part
 // of the C++ standard.
 
 using ::stdext::hash_map;
 using ::stdext::hash_set;
 using ::stdext::hash_multimap;
@@ skipping 307 matching lines @@
   EXPECT_THAT(Print(&Foo::MyVirtualMethod),
               StartsWith(Print(sizeof((&Foo::MyVirtualMethod)))
                                + "-byte object "));
   int (Foo::*p)(char) = NULL;  // NOLINT
   EXPECT_THAT(Print(p),
               StartsWith(Print(sizeof(p)) + "-byte object "));
 }
 
 // Tests printing C arrays.
 
-// One-dimensional array.
-
-void ArrayHelper1(int (&a)[5]) {  // NOLINT
-  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", Print(a));
+// The difference between this and Print() is that it ensures that the
+// argument is a reference to an array.
+template <typename T, size_t N>
+string PrintArrayHelper(T (&a)[N]) {
+  return Print(a);
 }
 
+// One-dimensional array.
 TEST(PrintArrayTest, OneDimensionalArray) {
   int a[5] = { 1, 2, 3, 4, 5 };
-  ArrayHelper1(a);
+  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
 }
 
 // Two-dimensional array.
-
-void ArrayHelper2(int (&a)[2][5]) {  // NOLINT
-  EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", Print(a));
-}
-
 TEST(PrintArrayTest, TwoDimensionalArray) {
   int a[2][5] = {
     { 1, 2, 3, 4, 5 },
     { 6, 7, 8, 9, 0 }
   };
-  ArrayHelper2(a);
+  EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
 }
 
 // Array of const elements.
-
-void ArrayHelper3(const bool (&a)[1]) {  // NOLINT
-  EXPECT_EQ("{ false }", Print(a));
-}
-
 TEST(PrintArrayTest, ConstArray) {
   const bool a[1] = { false };
-  ArrayHelper3(a);
+  EXPECT_EQ("{ false }", PrintArrayHelper(a));
 }
 
 // Char array.
-
-void ArrayHelper4(char (&a)[3]) {  // NOLINT
-  EXPECT_EQ(PrintPointer(a) + " pointing to \"Hi\"", Print(a));
-}
-
 TEST(PrintArrayTest, CharArray) {
-  char a[3] = "Hi";
-  ArrayHelper4(a);
+  // Array a contains '\0' in the middle and doesn't end with '\0'.
+  char a[3] = { 'H', '\0', 'i' };
+  EXPECT_EQ("\"H\\0i\"", PrintArrayHelper(a));
 }
 
 // Const char array.
-
-void ArrayHelper5(const char (&a)[3]) {  // NOLINT
-  EXPECT_EQ(Print(a), PrintPointer(a) + " pointing to \"Hi\"");
-}
-
 TEST(PrintArrayTest, ConstCharArray) {
-  const char a[3] = "Hi";
-  ArrayHelper5(a);
+  const char a[4] = "\0Hi";
+  EXPECT_EQ("\"\\0Hi\\0\"", PrintArrayHelper(a));
 }
 
 // Array of objects.
 TEST(PrintArrayTest, ObjectArray) {
   string a[3] = { "Hi", "Hello", "Ni hao" };
-  EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", Print(a));
+  EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", PrintArrayHelper(a));
 }
 
 // Array with many elements.
 TEST(PrintArrayTest, BigArray) {
   int a[100] = { 1, 2, 3 };
   EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
-            Print(a));
+            PrintArrayHelper(a));
 }
 
 // Tests printing ::string and ::std::string.
 
 #if GTEST_HAS_GLOBAL_STRING
 // ::string.
 TEST(PrintStringTest, StringInGlobalNamespace) {
   const char s[] = "'\"\?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
   const ::string str(s, sizeof(s));
   EXPECT_EQ("\"'\\\"\\?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
@@ skipping 229 matching lines @@
   const int a2[] = { 3, 4, 5 };
   const list<int> l1(a1, a1 + 2);
   const list<int> l2(a2, a2 + 3);
 
   vector<list<int> > v;
   v.push_back(l1);
   v.push_back(l2);
   EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
 }
 
+TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
+  const int a[] = { 1, 2, 3 };
+  NativeArray<int> b(a, kReference);
+  EXPECT_EQ("{ 1, 2, 3 }", Print(b));
+}
+
+TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
+  const int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
+  NativeArray<int[3]> b(a, kReference);
+  EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
+}
 
 // Tests printing tuples.
 
 // Tuples of various arities.
 TEST(PrintTupleTest, VariousSizes) {
   tuple<> t0;
   EXPECT_EQ("()", Print(t0));
 
   tuple<int> t1(5);
   EXPECT_EQ("(5)", Print(t1));
@@ skipping 172 matching lines @@
 TEST(PrintToStringTest, WorksForNonReference) {
   EXPECT_EQ("123", UniversalPrinter<int>::PrintToString(123));
 }
 
 TEST(PrintToStringTest, WorksForReference) {
   int n = 123;
   EXPECT_EQ("@" + PrintPointer(&n) + " 123",
             UniversalPrinter<const int&>::PrintToString(n));
 }
 
+TEST(PrintToStringTest, WorksForArray) {
+  int n[3] = { 1, 2, 3 };
+  EXPECT_EQ("{ 1, 2, 3 }", UniversalPrinter<int[3]>::PrintToString(n));
+}
+
 TEST(UniversalTersePrintTest, WorksForNonReference) {
   ::std::stringstream ss;
   UniversalTersePrint(123, &ss);
   EXPECT_EQ("123", ss.str());
 }
 
 TEST(UniversalTersePrintTest, WorksForReference) {
   const int& n = 123;
   ::std::stringstream ss;
   UniversalTersePrint(n, &ss);
@@ skipping 10 matching lines @@
   ::std::stringstream ss2;
   UniversalTersePrint(s2, &ss2);
   EXPECT_EQ("\"abc\"", ss2.str());
 
   const char* s3 = NULL;
   ::std::stringstream ss3;
   UniversalTersePrint(s3, &ss3);
   EXPECT_EQ("NULL", ss3.str());
 }
 
+TEST(UniversalPrintTest, WorksForNonReference) {
+  ::std::stringstream ss;
+  UniversalPrint(123, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalPrintTest, WorksForReference) {
+  const int& n = 123;
+  ::std::stringstream ss;
+  UniversalPrint(n, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalPrintTest, WorksForCString) {
+  const char* s1 = "abc";
+  ::std::stringstream ss1;
+  UniversalPrint(s1, &ss1);
+  EXPECT_EQ(PrintPointer(s1) + " pointing to \"abc\"", string(ss1.str()));
+
+  char* s2 = const_cast<char*>(s1);
+  ::std::stringstream ss2;
+  UniversalPrint(s2, &ss2);
+  EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", string(ss2.str()));
+
+  const char* s3 = NULL;
+  ::std::stringstream ss3;
+  UniversalPrint(s3, &ss3);
+  EXPECT_EQ("NULL", ss3.str());
+}
+
+
 TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsEmptyTuple) {
   EXPECT_THAT(UniversalTersePrintTupleFieldsToStrings(make_tuple()),
               ElementsAre());
 }
 
 TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsOneTuple) {
   EXPECT_THAT(UniversalTersePrintTupleFieldsToStrings(make_tuple(1)),
               ElementsAre("1"));
 }
 
 TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsTwoTuple) {
   EXPECT_THAT(UniversalTersePrintTupleFieldsToStrings(make_tuple(1, 'a')),
               ElementsAre("1", "'a' (97)"));
 }
 
 TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsTersely) {
   const int n = 1;
   EXPECT_THAT(UniversalTersePrintTupleFieldsToStrings(
                   tuple<const int&, const char*>(n, "a")),
               ElementsAre("1", "\"a\""));
 }
 
 }  // namespace gmock_printers_test
 }  // namespace testing