1// Copyright 2007, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10//     * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14//     * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29//
30// Author: wan@google.com (Zhanyong Wan)
31
32// Google Test - The Google C++ Testing Framework
33//
34// This file tests the universal value printer.
35
36#include "gtest/gtest-printers.h"
37
38#include <ctype.h>
39#include <limits.h>
40#include <string.h>
41#include <algorithm>
42#include <deque>
43#include <list>
44#include <map>
45#include <set>
46#include <sstream>
47#include <string>
48#include <utility>
49#include <vector>
50
51#include "gtest/gtest.h"
52
53// hash_map and hash_set are available under Visual C++.
54#if _MSC_VER
55# define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
56# include <hash_map>            // NOLINT
57# define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
58# include <hash_set>            // NOLINT
59#endif  // GTEST_OS_WINDOWS
60
61// Some user-defined types for testing the universal value printer.
62
63// An anonymous enum type.
64enum AnonymousEnum {
65  kAE1 = -1,
66  kAE2 = 1
67};
68
69// An enum without a user-defined printer.
70enum EnumWithoutPrinter {
71  kEWP1 = -2,
72  kEWP2 = 42
73};
74
75// An enum with a << operator.
76enum EnumWithStreaming {
77  kEWS1 = 10
78};
79
80std::ostream& operator<<(std::ostream& os, EnumWithStreaming e) {
81  return os << (e == kEWS1 ? "kEWS1" : "invalid");
82}
83
84// An enum with a PrintTo() function.
85enum EnumWithPrintTo {
86  kEWPT1 = 1
87};
88
89void PrintTo(EnumWithPrintTo e, std::ostream* os) {
90  *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
91}
92
93// A class implicitly convertible to BiggestInt.
94class BiggestIntConvertible {
95 public:
96  operator ::testing::internal::BiggestInt() const { return 42; }
97};
98
99// A user-defined unprintable class template in the global namespace.
100template <typename T>
101class UnprintableTemplateInGlobal {
102 public:
103  UnprintableTemplateInGlobal() : value_() {}
104 private:
105  T value_;
106};
107
108// A user-defined streamable type in the global namespace.
109class StreamableInGlobal {
110 public:
111  virtual ~StreamableInGlobal() {}
112};
113
114inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
115  os << "StreamableInGlobal";
116}
117
118void operator<<(::std::ostream& os, const StreamableInGlobal* /* x */) {
119  os << "StreamableInGlobal*";
120}
121
122namespace foo {
123
124// A user-defined unprintable type in a user namespace.
125class UnprintableInFoo {
126 public:
127  UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\x0", 8); }
128 private:
129  char xy_[8];
130  double z_;
131};
132
133// A user-defined printable type in a user-chosen namespace.
134struct PrintableViaPrintTo {
135  PrintableViaPrintTo() : value() {}
136  int value;
137};
138
139void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
140  *os << "PrintableViaPrintTo: " << x.value;
141}
142
143// A type with a user-defined << for printing its pointer.
144struct PointerPrintable {
145};
146
147::std::ostream& operator<<(::std::ostream& os,
148                           const PointerPrintable* /* x */) {
149  return os << "PointerPrintable*";
150}
151
152// A user-defined printable class template in a user-chosen namespace.
153template <typename T>
154class PrintableViaPrintToTemplate {
155 public:
156  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
157
158  const T& value() const { return value_; }
159 private:
160  T value_;
161};
162
163template <typename T>
164void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* os) {
165  *os << "PrintableViaPrintToTemplate: " << x.value();
166}
167
168// A user-defined streamable class template in a user namespace.
169template <typename T>
170class StreamableTemplateInFoo {
171 public:
172  StreamableTemplateInFoo() : value_() {}
173
174  const T& value() const { return value_; }
175 private:
176  T value_;
177};
178
179template <typename T>
180inline ::std::ostream& operator<<(::std::ostream& os,
181                                  const StreamableTemplateInFoo<T>& x) {
182  return os << "StreamableTemplateInFoo: " << x.value();
183}
184
185}  // namespace foo
186
187namespace testing {
188namespace gtest_printers_test {
189
190using ::std::deque;
191using ::std::list;
192using ::std::make_pair;
193using ::std::map;
194using ::std::multimap;
195using ::std::multiset;
196using ::std::pair;
197using ::std::set;
198using ::std::vector;
199using ::testing::PrintToString;
200using ::testing::internal::ImplicitCast_;
201using ::testing::internal::NativeArray;
202using ::testing::internal::RE;
203using ::testing::internal::Strings;
204using ::testing::internal::UniversalTersePrint;
205using ::testing::internal::UniversalPrint;
206using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
207using ::testing::internal::UniversalPrinter;
208using ::testing::internal::kReference;
209using ::testing::internal::string;
210
211#if GTEST_HAS_TR1_TUPLE
212using ::std::tr1::make_tuple;
213using ::std::tr1::tuple;
214#endif
215
216#if _MSC_VER
217// MSVC defines the following classes in the ::stdext namespace while
218// gcc defines them in the :: namespace.  Note that they are not part
219// of the C++ standard.
220using ::stdext::hash_map;
221using ::stdext::hash_set;
222using ::stdext::hash_multimap;
223using ::stdext::hash_multiset;
224#endif
225
226// Prints a value to a string using the universal value printer.  This
227// is a helper for testing UniversalPrinter<T>::Print() for various types.
228template <typename T>
229string Print(const T& value) {
230  ::std::stringstream ss;
231  UniversalPrinter<T>::Print(value, &ss);
232  return ss.str();
233}
234
235// Prints a value passed by reference to a string, using the universal
236// value printer.  This is a helper for testing
237// UniversalPrinter<T&>::Print() for various types.
238template <typename T>
239string PrintByRef(const T& value) {
240  ::std::stringstream ss;
241  UniversalPrinter<T&>::Print(value, &ss);
242  return ss.str();
243}
244
245// Tests printing various enum types.
246
247TEST(PrintEnumTest, AnonymousEnum) {
248  EXPECT_EQ("-1", Print(kAE1));
249  EXPECT_EQ("1", Print(kAE2));
250}
251
252TEST(PrintEnumTest, EnumWithoutPrinter) {
253  EXPECT_EQ("-2", Print(kEWP1));
254  EXPECT_EQ("42", Print(kEWP2));
255}
256
257TEST(PrintEnumTest, EnumWithStreaming) {
258  EXPECT_EQ("kEWS1", Print(kEWS1));
259  EXPECT_EQ("invalid", Print(static_cast<EnumWithStreaming>(0)));
260}
261
262TEST(PrintEnumTest, EnumWithPrintTo) {
263  EXPECT_EQ("kEWPT1", Print(kEWPT1));
264  EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
265}
266
267// Tests printing a class implicitly convertible to BiggestInt.
268
269TEST(PrintClassTest, BiggestIntConvertible) {
270  EXPECT_EQ("42", Print(BiggestIntConvertible()));
271}
272
273// Tests printing various char types.
274
275// char.
276TEST(PrintCharTest, PlainChar) {
277  EXPECT_EQ("'\\0'", Print('\0'));
278  EXPECT_EQ("'\\'' (39, 0x27)", Print('\''));
279  EXPECT_EQ("'\"' (34, 0x22)", Print('"'));
280  EXPECT_EQ("'?' (63, 0x3F)", Print('?'));
281  EXPECT_EQ("'\\\\' (92, 0x5C)", Print('\\'));
282  EXPECT_EQ("'\\a' (7)", Print('\a'));
283  EXPECT_EQ("'\\b' (8)", Print('\b'));
284  EXPECT_EQ("'\\f' (12, 0xC)", Print('\f'));
285  EXPECT_EQ("'\\n' (10, 0xA)", Print('\n'));
286  EXPECT_EQ("'\\r' (13, 0xD)", Print('\r'));
287  EXPECT_EQ("'\\t' (9)", Print('\t'));
288  EXPECT_EQ("'\\v' (11, 0xB)", Print('\v'));
289  EXPECT_EQ("'\\x7F' (127)", Print('\x7F'));
290  EXPECT_EQ("'\\xFF' (255)", Print('\xFF'));
291  EXPECT_EQ("' ' (32, 0x20)", Print(' '));
292  EXPECT_EQ("'a' (97, 0x61)", Print('a'));
293}
294
295// signed char.
296TEST(PrintCharTest, SignedChar) {
297  EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));
298  EXPECT_EQ("'\\xCE' (-50)",
299            Print(static_cast<signed char>(-50)));
300}
301
302// unsigned char.
303TEST(PrintCharTest, UnsignedChar) {
304  EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));
305  EXPECT_EQ("'b' (98, 0x62)",
306            Print(static_cast<unsigned char>('b')));
307}
308
309// Tests printing other simple, built-in types.
310
311// bool.
312TEST(PrintBuiltInTypeTest, Bool) {
313  EXPECT_EQ("false", Print(false));
314  EXPECT_EQ("true", Print(true));
315}
316
317// wchar_t.
318TEST(PrintBuiltInTypeTest, Wchar_t) {
319  EXPECT_EQ("L'\\0'", Print(L'\0'));
320  EXPECT_EQ("L'\\'' (39, 0x27)", Print(L'\''));
321  EXPECT_EQ("L'\"' (34, 0x22)", Print(L'"'));
322  EXPECT_EQ("L'?' (63, 0x3F)", Print(L'?'));
323  EXPECT_EQ("L'\\\\' (92, 0x5C)", Print(L'\\'));
324  EXPECT_EQ("L'\\a' (7)", Print(L'\a'));
325  EXPECT_EQ("L'\\b' (8)", Print(L'\b'));
326  EXPECT_EQ("L'\\f' (12, 0xC)", Print(L'\f'));
327  EXPECT_EQ("L'\\n' (10, 0xA)", Print(L'\n'));
328  EXPECT_EQ("L'\\r' (13, 0xD)", Print(L'\r'));
329  EXPECT_EQ("L'\\t' (9)", Print(L'\t'));
330  EXPECT_EQ("L'\\v' (11, 0xB)", Print(L'\v'));
331  EXPECT_EQ("L'\\x7F' (127)", Print(L'\x7F'));
332  EXPECT_EQ("L'\\xFF' (255)", Print(L'\xFF'));
333  EXPECT_EQ("L' ' (32, 0x20)", Print(L' '));
334  EXPECT_EQ("L'a' (97, 0x61)", Print(L'a'));
335  EXPECT_EQ("L'\\x576' (1398)", Print(static_cast<wchar_t>(0x576)));
336  EXPECT_EQ("L'\\xC74D' (51021)", Print(static_cast<wchar_t>(0xC74D)));
337}
338
339// Test that Int64 provides more storage than wchar_t.
340TEST(PrintTypeSizeTest, Wchar_t) {
341  EXPECT_LT(sizeof(wchar_t), sizeof(testing::internal::Int64));
342}
343
344// Various integer types.
345TEST(PrintBuiltInTypeTest, Integer) {
346  EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8
347  EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8
348  EXPECT_EQ("65535", Print(USHRT_MAX));  // uint16
349  EXPECT_EQ("-32768", Print(SHRT_MIN));  // int16
350  EXPECT_EQ("4294967295", Print(UINT_MAX));  // uint32
351  EXPECT_EQ("-2147483648", Print(INT_MIN));  // int32
352  EXPECT_EQ("18446744073709551615",
353            Print(static_cast<testing::internal::UInt64>(-1)));  // uint64
354  EXPECT_EQ("-9223372036854775808",
355            Print(static_cast<testing::internal::Int64>(1) << 63));  // int64
356}
357
358// Size types.
359TEST(PrintBuiltInTypeTest, Size_t) {
360  EXPECT_EQ("1", Print(sizeof('a')));  // size_t.
361#if !GTEST_OS_WINDOWS
362  // Windows has no ssize_t type.
363  EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.
364#endif  // !GTEST_OS_WINDOWS
365}
366
367// Floating-points.
368TEST(PrintBuiltInTypeTest, FloatingPoints) {
369  EXPECT_EQ("1.5", Print(1.5f));   // float
370  EXPECT_EQ("-2.5", Print(-2.5));  // double
371}
372
373// Since ::std::stringstream::operator<<(const void *) formats the pointer
374// output differently with different compilers, we have to create the expected
375// output first and use it as our expectation.
376static string PrintPointer(const void *p) {
377  ::std::stringstream expected_result_stream;
378  expected_result_stream << p;
379  return expected_result_stream.str();
380}
381
382// Tests printing C strings.
383
384// const char*.
385TEST(PrintCStringTest, Const) {
386  const char* p = "World";
387  EXPECT_EQ(PrintPointer(p) + " pointing to \"World\"", Print(p));
388}
389
390// char*.
391TEST(PrintCStringTest, NonConst) {
392  char p[] = "Hi";
393  EXPECT_EQ(PrintPointer(p) + " pointing to \"Hi\"",
394            Print(static_cast<char*>(p)));
395}
396
397// NULL C string.
398TEST(PrintCStringTest, Null) {
399  const char* p = NULL;
400  EXPECT_EQ("NULL", Print(p));
401}
402
403// Tests that C strings are escaped properly.
404TEST(PrintCStringTest, EscapesProperly) {
405  const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
406  EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"
407            "\\n\\r\\t\\v\\x7F\\xFF a\"",
408            Print(p));
409}
410
411
412
413// MSVC compiler can be configured to define whar_t as a typedef
414// of unsigned short. Defining an overload for const wchar_t* in that case
415// would cause pointers to unsigned shorts be printed as wide strings,
416// possibly accessing more memory than intended and causing invalid
417// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
418// wchar_t is implemented as a native type.
419#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
420
421// const wchar_t*.
422TEST(PrintWideCStringTest, Const) {
423  const wchar_t* p = L"World";
424  EXPECT_EQ(PrintPointer(p) + " pointing to L\"World\"", Print(p));
425}
426
427// wchar_t*.
428TEST(PrintWideCStringTest, NonConst) {
429  wchar_t p[] = L"Hi";
430  EXPECT_EQ(PrintPointer(p) + " pointing to L\"Hi\"",
431            Print(static_cast<wchar_t*>(p)));
432}
433
434// NULL wide C string.
435TEST(PrintWideCStringTest, Null) {
436  const wchar_t* p = NULL;
437  EXPECT_EQ("NULL", Print(p));
438}
439
440// Tests that wide C strings are escaped properly.
441TEST(PrintWideCStringTest, EscapesProperly) {
442  const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',
443                       '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};
444  EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"
445            "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
446            Print(static_cast<const wchar_t*>(s)));
447}
448#endif  // native wchar_t
449
450// Tests printing pointers to other char types.
451
452// signed char*.
453TEST(PrintCharPointerTest, SignedChar) {
454  signed char* p = reinterpret_cast<signed char*>(0x1234);
455  EXPECT_EQ(PrintPointer(p), Print(p));
456  p = NULL;
457  EXPECT_EQ("NULL", Print(p));
458}
459
460// const signed char*.
461TEST(PrintCharPointerTest, ConstSignedChar) {
462  signed char* p = reinterpret_cast<signed char*>(0x1234);
463  EXPECT_EQ(PrintPointer(p), Print(p));
464  p = NULL;
465  EXPECT_EQ("NULL", Print(p));
466}
467
468// unsigned char*.
469TEST(PrintCharPointerTest, UnsignedChar) {
470  unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);
471  EXPECT_EQ(PrintPointer(p), Print(p));
472  p = NULL;
473  EXPECT_EQ("NULL", Print(p));
474}
475
476// const unsigned char*.
477TEST(PrintCharPointerTest, ConstUnsignedChar) {
478  const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);
479  EXPECT_EQ(PrintPointer(p), Print(p));
480  p = NULL;
481  EXPECT_EQ("NULL", Print(p));
482}
483
484// Tests printing pointers to simple, built-in types.
485
486// bool*.
487TEST(PrintPointerToBuiltInTypeTest, Bool) {
488  bool* p = reinterpret_cast<bool*>(0xABCD);
489  EXPECT_EQ(PrintPointer(p), Print(p));
490  p = NULL;
491  EXPECT_EQ("NULL", Print(p));
492}
493
494// void*.
495TEST(PrintPointerToBuiltInTypeTest, Void) {
496  void* p = reinterpret_cast<void*>(0xABCD);
497  EXPECT_EQ(PrintPointer(p), Print(p));
498  p = NULL;
499  EXPECT_EQ("NULL", Print(p));
500}
501
502// const void*.
503TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
504  const void* p = reinterpret_cast<const void*>(0xABCD);
505  EXPECT_EQ(PrintPointer(p), Print(p));
506  p = NULL;
507  EXPECT_EQ("NULL", Print(p));
508}
509
510// Tests printing pointers to pointers.
511TEST(PrintPointerToPointerTest, IntPointerPointer) {
512  int** p = reinterpret_cast<int**>(0xABCD);
513  EXPECT_EQ(PrintPointer(p), Print(p));
514  p = NULL;
515  EXPECT_EQ("NULL", Print(p));
516}
517
518// Tests printing (non-member) function pointers.
519
520void MyFunction(int /* n */) {}
521
522TEST(PrintPointerTest, NonMemberFunctionPointer) {
523  // We cannot directly cast &MyFunction to const void* because the
524  // standard disallows casting between pointers to functions and
525  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
526  // this limitation.
527  EXPECT_EQ(
528      PrintPointer(reinterpret_cast<const void*>(
529          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
530      Print(&MyFunction));
531  int (*p)(bool) = NULL;  // NOLINT
532  EXPECT_EQ("NULL", Print(p));
533}
534
535// An assertion predicate determining whether a one string is a prefix for
536// another.
537template <typename StringType>
538AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {
539  if (str.find(prefix, 0) == 0)
540    return AssertionSuccess();
541
542  const bool is_wide_string = sizeof(prefix[0]) > 1;
543  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
544  return AssertionFailure()
545      << begin_string_quote << prefix << "\" is not a prefix of "
546      << begin_string_quote << str << "\"\n";
547}
548
549// Tests printing member variable pointers.  Although they are called
550// pointers, they don't point to a location in the address space.
551// Their representation is implementation-defined.  Thus they will be
552// printed as raw bytes.
553
554struct Foo {
555 public:
556  virtual ~Foo() {}
557  int MyMethod(char x) { return x + 1; }
558  virtual char MyVirtualMethod(int /* n */) { return 'a'; }
559
560  int value;
561};
562
563TEST(PrintPointerTest, MemberVariablePointer) {
564  EXPECT_TRUE(HasPrefix(Print(&Foo::value),
565                        Print(sizeof(&Foo::value)) + "-byte object "));
566  int (Foo::*p) = NULL;  // NOLINT
567  EXPECT_TRUE(HasPrefix(Print(p),
568                        Print(sizeof(p)) + "-byte object "));
569}
570
571// Tests printing member function pointers.  Although they are called
572// pointers, they don't point to a location in the address space.
573// Their representation is implementation-defined.  Thus they will be
574// printed as raw bytes.
575TEST(PrintPointerTest, MemberFunctionPointer) {
576  EXPECT_TRUE(HasPrefix(Print(&Foo::MyMethod),
577                        Print(sizeof(&Foo::MyMethod)) + "-byte object "));
578  EXPECT_TRUE(
579      HasPrefix(Print(&Foo::MyVirtualMethod),
580                Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));
581  int (Foo::*p)(char) = NULL;  // NOLINT
582  EXPECT_TRUE(HasPrefix(Print(p),
583                        Print(sizeof(p)) + "-byte object "));
584}
585
586// Tests printing C arrays.
587
588// The difference between this and Print() is that it ensures that the
589// argument is a reference to an array.
590template <typename T, size_t N>
591string PrintArrayHelper(T (&a)[N]) {
592  return Print(a);
593}
594
595// One-dimensional array.
596TEST(PrintArrayTest, OneDimensionalArray) {
597  int a[5] = { 1, 2, 3, 4, 5 };
598  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
599}
600
601// Two-dimensional array.
602TEST(PrintArrayTest, TwoDimensionalArray) {
603  int a[2][5] = {
604    { 1, 2, 3, 4, 5 },
605    { 6, 7, 8, 9, 0 }
606  };
607  EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
608}
609
610// Array of const elements.
611TEST(PrintArrayTest, ConstArray) {
612  const bool a[1] = { false };
613  EXPECT_EQ("{ false }", PrintArrayHelper(a));
614}
615
616// Char array.
617TEST(PrintArrayTest, CharArray) {
618  // Array a contains '\0' in the middle and doesn't end with '\0'.
619  char a[3] = { 'H', '\0', 'i' };
620  EXPECT_EQ("\"H\\0i\"", PrintArrayHelper(a));
621}
622
623// Const char array.
624TEST(PrintArrayTest, ConstCharArray) {
625  const char a[4] = "\0Hi";
626  EXPECT_EQ("\"\\0Hi\\0\"", PrintArrayHelper(a));
627}
628
629// Array of objects.
630TEST(PrintArrayTest, ObjectArray) {
631  string a[3] = { "Hi", "Hello", "Ni hao" };
632  EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", PrintArrayHelper(a));
633}
634
635// Array with many elements.
636TEST(PrintArrayTest, BigArray) {
637  int a[100] = { 1, 2, 3 };
638  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
639            PrintArrayHelper(a));
640}
641
642// Tests printing ::string and ::std::string.
643
644#if GTEST_HAS_GLOBAL_STRING
645// ::string.
646TEST(PrintStringTest, StringInGlobalNamespace) {
647  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
648  const ::string str(s, sizeof(s));
649  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
650            Print(str));
651}
652#endif  // GTEST_HAS_GLOBAL_STRING
653
654// ::std::string.
655TEST(PrintStringTest, StringInStdNamespace) {
656  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
657  const ::std::string str(s, sizeof(s));
658  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
659            Print(str));
660}
661
662TEST(PrintStringTest, StringAmbiguousHex) {
663  // "\x6BANANA" is ambiguous, it can be interpreted as starting with either of:
664  // '\x6', '\x6B', or '\x6BA'.
665
666  // a hex escaping sequence following by a decimal digit
667  EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12" "3")));
668  // a hex escaping sequence following by a hex digit (lower-case)
669  EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6" "bananas")));
670  // a hex escaping sequence following by a hex digit (upper-case)
671  EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6" "BANANA")));
672  // a hex escaping sequence following by a non-xdigit
673  EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
674}
675
676// Tests printing ::wstring and ::std::wstring.
677
678#if GTEST_HAS_GLOBAL_WSTRING
679// ::wstring.
680TEST(PrintWideStringTest, StringInGlobalNamespace) {
681  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
682  const ::wstring str(s, sizeof(s)/sizeof(wchar_t));
683  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
684            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
685            Print(str));
686}
687#endif  // GTEST_HAS_GLOBAL_WSTRING
688
689#if GTEST_HAS_STD_WSTRING
690// ::std::wstring.
691TEST(PrintWideStringTest, StringInStdNamespace) {
692  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
693  const ::std::wstring str(s, sizeof(s)/sizeof(wchar_t));
694  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
695            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
696            Print(str));
697}
698
699TEST(PrintWideStringTest, StringAmbiguousHex) {
700  // same for wide strings.
701  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12" L"3")));
702  EXPECT_EQ("L\"mm\\x6\" L\"bananas\"",
703            Print(::std::wstring(L"mm\x6" L"bananas")));
704  EXPECT_EQ("L\"NOM\\x6\" L\"BANANA\"",
705            Print(::std::wstring(L"NOM\x6" L"BANANA")));
706  EXPECT_EQ("L\"!\\x5-!\"", Print(::std::wstring(L"!\x5-!")));
707}
708#endif  // GTEST_HAS_STD_WSTRING
709
710// Tests printing types that support generic streaming (i.e. streaming
711// to std::basic_ostream<Char, CharTraits> for any valid Char and
712// CharTraits types).
713
714// Tests printing a non-template type that supports generic streaming.
715
716class AllowsGenericStreaming {};
717
718template <typename Char, typename CharTraits>
719std::basic_ostream<Char, CharTraits>& operator<<(
720    std::basic_ostream<Char, CharTraits>& os,
721    const AllowsGenericStreaming& /* a */) {
722  return os << "AllowsGenericStreaming";
723}
724
725TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
726  AllowsGenericStreaming a;
727  EXPECT_EQ("AllowsGenericStreaming", Print(a));
728}
729
730// Tests printing a template type that supports generic streaming.
731
732template <typename T>
733class AllowsGenericStreamingTemplate {};
734
735template <typename Char, typename CharTraits, typename T>
736std::basic_ostream<Char, CharTraits>& operator<<(
737    std::basic_ostream<Char, CharTraits>& os,
738    const AllowsGenericStreamingTemplate<T>& /* a */) {
739  return os << "AllowsGenericStreamingTemplate";
740}
741
742TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
743  AllowsGenericStreamingTemplate<int> a;
744  EXPECT_EQ("AllowsGenericStreamingTemplate", Print(a));
745}
746
747// Tests printing a type that supports generic streaming and can be
748// implicitly converted to another printable type.
749
750template <typename T>
751class AllowsGenericStreamingAndImplicitConversionTemplate {
752 public:
753  operator bool() const { return false; }
754};
755
756template <typename Char, typename CharTraits, typename T>
757std::basic_ostream<Char, CharTraits>& operator<<(
758    std::basic_ostream<Char, CharTraits>& os,
759    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
760  return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
761}
762
763TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
764  AllowsGenericStreamingAndImplicitConversionTemplate<int> a;
765  EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
766}
767
768#if GTEST_HAS_STRING_PIECE_
769
770// Tests printing StringPiece.
771
772TEST(PrintStringPieceTest, SimpleStringPiece) {
773  const StringPiece sp = "Hello";
774  EXPECT_EQ("\"Hello\"", Print(sp));
775}
776
777TEST(PrintStringPieceTest, UnprintableCharacters) {
778  const char str[] = "NUL (\0) and \r\t";
779  const StringPiece sp(str, sizeof(str) - 1);
780  EXPECT_EQ("\"NUL (\\0) and \\r\\t\"", Print(sp));
781}
782
783#endif  // GTEST_HAS_STRING_PIECE_
784
785// Tests printing STL containers.
786
787TEST(PrintStlContainerTest, EmptyDeque) {
788  deque<char> empty;
789  EXPECT_EQ("{}", Print(empty));
790}
791
792TEST(PrintStlContainerTest, NonEmptyDeque) {
793  deque<int> non_empty;
794  non_empty.push_back(1);
795  non_empty.push_back(3);
796  EXPECT_EQ("{ 1, 3 }", Print(non_empty));
797}
798
799#if GTEST_HAS_HASH_MAP_
800
801TEST(PrintStlContainerTest, OneElementHashMap) {
802  hash_map<int, char> map1;
803  map1[1] = 'a';
804  EXPECT_EQ("{ (1, 'a' (97, 0x61)) }", Print(map1));
805}
806
807TEST(PrintStlContainerTest, HashMultiMap) {
808  hash_multimap<int, bool> map1;
809  map1.insert(make_pair(5, true));
810  map1.insert(make_pair(5, false));
811
812  // Elements of hash_multimap can be printed in any order.
813  const string result = Print(map1);
814  EXPECT_TRUE(result == "{ (5, true), (5, false) }" ||
815              result == "{ (5, false), (5, true) }")
816                  << " where Print(map1) returns \"" << result << "\".";
817}
818
819#endif  // GTEST_HAS_HASH_MAP_
820
821#if GTEST_HAS_HASH_SET_
822
823TEST(PrintStlContainerTest, HashSet) {
824  hash_set<string> set1;
825  set1.insert("hello");
826  EXPECT_EQ("{ \"hello\" }", Print(set1));
827}
828
829TEST(PrintStlContainerTest, HashMultiSet) {
830  const int kSize = 5;
831  int a[kSize] = { 1, 1, 2, 5, 1 };
832  hash_multiset<int> set1(a, a + kSize);
833
834  // Elements of hash_multiset can be printed in any order.
835  const string result = Print(set1);
836  const string expected_pattern = "{ d, d, d, d, d }";  // d means a digit.
837
838  // Verifies the result matches the expected pattern; also extracts
839  // the numbers in the result.
840  ASSERT_EQ(expected_pattern.length(), result.length());
841  std::vector<int> numbers;
842  for (size_t i = 0; i != result.length(); i++) {
843    if (expected_pattern[i] == 'd') {
844      ASSERT_NE(isdigit(static_cast<unsigned char>(result[i])), 0);
845      numbers.push_back(result[i] - '0');
846    } else {
847      EXPECT_EQ(expected_pattern[i], result[i]) << " where result is "
848                                                << result;
849    }
850  }
851
852  // Makes sure the result contains the right numbers.
853  std::sort(numbers.begin(), numbers.end());
854  std::sort(a, a + kSize);
855  EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
856}
857
858#endif  // GTEST_HAS_HASH_SET_
859
860TEST(PrintStlContainerTest, List) {
861  const string a[] = {
862    "hello",
863    "world"
864  };
865  const list<string> strings(a, a + 2);
866  EXPECT_EQ("{ \"hello\", \"world\" }", Print(strings));
867}
868
869TEST(PrintStlContainerTest, Map) {
870  map<int, bool> map1;
871  map1[1] = true;
872  map1[5] = false;
873  map1[3] = true;
874  EXPECT_EQ("{ (1, true), (3, true), (5, false) }", Print(map1));
875}
876
877TEST(PrintStlContainerTest, MultiMap) {
878  multimap<bool, int> map1;
879  // The make_pair template function would deduce the type as
880  // pair<bool, int> here, and since the key part in a multimap has to
881  // be constant, without a templated ctor in the pair class (as in
882  // libCstd on Solaris), make_pair call would fail to compile as no
883  // implicit conversion is found.  Thus explicit typename is used
884  // here instead.
885  map1.insert(pair<const bool, int>(true, 0));
886  map1.insert(pair<const bool, int>(true, 1));
887  map1.insert(pair<const bool, int>(false, 2));
888  EXPECT_EQ("{ (false, 2), (true, 0), (true, 1) }", Print(map1));
889}
890
891TEST(PrintStlContainerTest, Set) {
892  const unsigned int a[] = { 3, 0, 5 };
893  set<unsigned int> set1(a, a + 3);
894  EXPECT_EQ("{ 0, 3, 5 }", Print(set1));
895}
896
897TEST(PrintStlContainerTest, MultiSet) {
898  const int a[] = { 1, 1, 2, 5, 1 };
899  multiset<int> set1(a, a + 5);
900  EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
901}
902
903TEST(PrintStlContainerTest, Pair) {
904  pair<const bool, int> p(true, 5);
905  EXPECT_EQ("(true, 5)", Print(p));
906}
907
908TEST(PrintStlContainerTest, Vector) {
909  vector<int> v;
910  v.push_back(1);
911  v.push_back(2);
912  EXPECT_EQ("{ 1, 2 }", Print(v));
913}
914
915TEST(PrintStlContainerTest, LongSequence) {
916  const int a[100] = { 1, 2, 3 };
917  const vector<int> v(a, a + 100);
918  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
919            "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }", Print(v));
920}
921
922TEST(PrintStlContainerTest, NestedContainer) {
923  const int a1[] = { 1, 2 };
924  const int a2[] = { 3, 4, 5 };
925  const list<int> l1(a1, a1 + 2);
926  const list<int> l2(a2, a2 + 3);
927
928  vector<list<int> > v;
929  v.push_back(l1);
930  v.push_back(l2);
931  EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
932}
933
934TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
935  const int a[3] = { 1, 2, 3 };
936  NativeArray<int> b(a, 3, kReference);
937  EXPECT_EQ("{ 1, 2, 3 }", Print(b));
938}
939
940TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
941  const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
942  NativeArray<int[3]> b(a, 2, kReference);
943  EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
944}
945
946// Tests that a class named iterator isn't treated as a container.
947
948struct iterator {
949  char x;
950};
951
952TEST(PrintStlContainerTest, Iterator) {
953  iterator it = {};
954  EXPECT_EQ("1-byte object <00>", Print(it));
955}
956
957// Tests that a class named const_iterator isn't treated as a container.
958
959struct const_iterator {
960  char x;
961};
962
963TEST(PrintStlContainerTest, ConstIterator) {
964  const_iterator it = {};
965  EXPECT_EQ("1-byte object <00>", Print(it));
966}
967
968#if GTEST_HAS_TR1_TUPLE
969// Tests printing tuples.
970
971// Tuples of various arities.
972TEST(PrintTupleTest, VariousSizes) {
973  tuple<> t0;
974  EXPECT_EQ("()", Print(t0));
975
976  tuple<int> t1(5);
977  EXPECT_EQ("(5)", Print(t1));
978
979  tuple<char, bool> t2('a', true);
980  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
981
982  tuple<bool, int, int> t3(false, 2, 3);
983  EXPECT_EQ("(false, 2, 3)", Print(t3));
984
985  tuple<bool, int, int, int> t4(false, 2, 3, 4);
986  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
987
988  tuple<bool, int, int, int, bool> t5(false, 2, 3, 4, true);
989  EXPECT_EQ("(false, 2, 3, 4, true)", Print(t5));
990
991  tuple<bool, int, int, int, bool, int> t6(false, 2, 3, 4, true, 6);
992  EXPECT_EQ("(false, 2, 3, 4, true, 6)", Print(t6));
993
994  tuple<bool, int, int, int, bool, int, int> t7(false, 2, 3, 4, true, 6, 7);
995  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7)", Print(t7));
996
997  tuple<bool, int, int, int, bool, int, int, bool> t8(
998      false, 2, 3, 4, true, 6, 7, true);
999  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true)", Print(t8));
1000
1001  tuple<bool, int, int, int, bool, int, int, bool, int> t9(
1002      false, 2, 3, 4, true, 6, 7, true, 9);
1003  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true, 9)", Print(t9));
1004
1005  const char* const str = "8";
1006  // VC++ 2010's implementation of tuple of C++0x is deficient, requiring
1007  // an explicit type cast of NULL to be used.
1008  tuple<bool, char, short, testing::internal::Int32,  // NOLINT
1009      testing::internal::Int64, float, double, const char*, void*, string>
1010      t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str,
1011          ImplicitCast_<void*>(NULL), "10");
1012  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
1013            " pointing to \"8\", NULL, \"10\")",
1014            Print(t10));
1015}
1016
1017// Nested tuples.
1018TEST(PrintTupleTest, NestedTuple) {
1019  tuple<tuple<int, bool>, char> nested(make_tuple(5, true), 'a');
1020  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
1021}
1022
1023#endif  // GTEST_HAS_TR1_TUPLE
1024
1025// Tests printing user-defined unprintable types.
1026
1027// Unprintable types in the global namespace.
1028TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
1029  EXPECT_EQ("1-byte object <00>",
1030            Print(UnprintableTemplateInGlobal<char>()));
1031}
1032
1033// Unprintable types in a user namespace.
1034TEST(PrintUnprintableTypeTest, InUserNamespace) {
1035  EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1036            Print(::foo::UnprintableInFoo()));
1037}
1038
1039// Unprintable types are that too big to be printed completely.
1040
1041struct Big {
1042  Big() { memset(array, 0, sizeof(array)); }
1043  char array[257];
1044};
1045
1046TEST(PrintUnpritableTypeTest, BigObject) {
1047  EXPECT_EQ("257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
1048            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1049            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1050            "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
1051            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1052            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1053            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
1054            Print(Big()));
1055}
1056
1057// Tests printing user-defined streamable types.
1058
1059// Streamable types in the global namespace.
1060TEST(PrintStreamableTypeTest, InGlobalNamespace) {
1061  StreamableInGlobal x;
1062  EXPECT_EQ("StreamableInGlobal", Print(x));
1063  EXPECT_EQ("StreamableInGlobal*", Print(&x));
1064}
1065
1066// Printable template types in a user namespace.
1067TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
1068  EXPECT_EQ("StreamableTemplateInFoo: 0",
1069            Print(::foo::StreamableTemplateInFoo<int>()));
1070}
1071
1072// Tests printing user-defined types that have a PrintTo() function.
1073TEST(PrintPrintableTypeTest, InUserNamespace) {
1074  EXPECT_EQ("PrintableViaPrintTo: 0",
1075            Print(::foo::PrintableViaPrintTo()));
1076}
1077
1078// Tests printing a pointer to a user-defined type that has a <<
1079// operator for its pointer.
1080TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
1081  ::foo::PointerPrintable x;
1082  EXPECT_EQ("PointerPrintable*", Print(&x));
1083}
1084
1085// Tests printing user-defined class template that have a PrintTo() function.
1086TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
1087  EXPECT_EQ("PrintableViaPrintToTemplate: 5",
1088            Print(::foo::PrintableViaPrintToTemplate<int>(5)));
1089}
1090
1091#if GTEST_HAS_PROTOBUF_
1092
1093// Tests printing a protocol message.
1094TEST(PrintProtocolMessageTest, PrintsShortDebugString) {
1095  testing::internal::TestMessage msg;
1096  msg.set_member("yes");
1097  EXPECT_EQ("<member:\"yes\">", Print(msg));
1098}
1099
1100// Tests printing a short proto2 message.
1101TEST(PrintProto2MessageTest, PrintsShortDebugStringWhenItIsShort) {
1102  testing::internal::FooMessage msg;
1103  msg.set_int_field(2);
1104  msg.set_string_field("hello");
1105  EXPECT_PRED2(RE::FullMatch, Print(msg),
1106               "<int_field:\\s*2\\s+string_field:\\s*\"hello\">");
1107}
1108
1109// Tests printing a long proto2 message.
1110TEST(PrintProto2MessageTest, PrintsDebugStringWhenItIsLong) {
1111  testing::internal::FooMessage msg;
1112  msg.set_int_field(2);
1113  msg.set_string_field("hello");
1114  msg.add_names("peter");
1115  msg.add_names("paul");
1116  msg.add_names("mary");
1117  EXPECT_PRED2(RE::FullMatch, Print(msg),
1118               "<\n"
1119               "int_field:\\s*2\n"
1120               "string_field:\\s*\"hello\"\n"
1121               "names:\\s*\"peter\"\n"
1122               "names:\\s*\"paul\"\n"
1123               "names:\\s*\"mary\"\n"
1124               ">");
1125}
1126
1127#endif  // GTEST_HAS_PROTOBUF_
1128
1129// Tests that the universal printer prints both the address and the
1130// value of a reference.
1131TEST(PrintReferenceTest, PrintsAddressAndValue) {
1132  int n = 5;
1133  EXPECT_EQ("@" + PrintPointer(&n) + " 5", PrintByRef(n));
1134
1135  int a[2][3] = {
1136    { 0, 1, 2 },
1137    { 3, 4, 5 }
1138  };
1139  EXPECT_EQ("@" + PrintPointer(a) + " { { 0, 1, 2 }, { 3, 4, 5 } }",
1140            PrintByRef(a));
1141
1142  const ::foo::UnprintableInFoo x;
1143  EXPECT_EQ("@" + PrintPointer(&x) + " 16-byte object "
1144            "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1145            PrintByRef(x));
1146}
1147
1148// Tests that the universal printer prints a function pointer passed by
1149// reference.
1150TEST(PrintReferenceTest, HandlesFunctionPointer) {
1151  void (*fp)(int n) = &MyFunction;
1152  const string fp_pointer_string =
1153      PrintPointer(reinterpret_cast<const void*>(&fp));
1154  // We cannot directly cast &MyFunction to const void* because the
1155  // standard disallows casting between pointers to functions and
1156  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
1157  // this limitation.
1158  const string fp_string = PrintPointer(reinterpret_cast<const void*>(
1159      reinterpret_cast<internal::BiggestInt>(fp)));
1160  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
1161            PrintByRef(fp));
1162}
1163
1164// Tests that the universal printer prints a member function pointer
1165// passed by reference.
1166TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
1167  int (Foo::*p)(char ch) = &Foo::MyMethod;
1168  EXPECT_TRUE(HasPrefix(
1169      PrintByRef(p),
1170      "@" + PrintPointer(reinterpret_cast<const void*>(&p)) + " " +
1171          Print(sizeof(p)) + "-byte object "));
1172
1173  char (Foo::*p2)(int n) = &Foo::MyVirtualMethod;
1174  EXPECT_TRUE(HasPrefix(
1175      PrintByRef(p2),
1176      "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) + " " +
1177          Print(sizeof(p2)) + "-byte object "));
1178}
1179
1180// Tests that the universal printer prints a member variable pointer
1181// passed by reference.
1182TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
1183  int (Foo::*p) = &Foo::value;  // NOLINT
1184  EXPECT_TRUE(HasPrefix(
1185      PrintByRef(p),
1186      "@" + PrintPointer(&p) + " " + Print(sizeof(p)) + "-byte object "));
1187}
1188
1189// Useful for testing PrintToString().  We cannot use EXPECT_EQ()
1190// there as its implementation uses PrintToString().  The caller must
1191// ensure that 'value' has no side effect.
1192#define EXPECT_PRINT_TO_STRING_(value, expected_string)         \
1193  EXPECT_TRUE(PrintToString(value) == (expected_string))        \
1194      << " where " #value " prints as " << (PrintToString(value))
1195
1196TEST(PrintToStringTest, WorksForScalar) {
1197  EXPECT_PRINT_TO_STRING_(123, "123");
1198}
1199
1200TEST(PrintToStringTest, WorksForPointerToConstChar) {
1201  const char* p = "hello";
1202  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
1203}
1204
1205TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
1206  char s[] = "hello";
1207  char* p = s;
1208  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
1209}
1210
1211TEST(PrintToStringTest, WorksForArray) {
1212  int n[3] = { 1, 2, 3 };
1213  EXPECT_PRINT_TO_STRING_(n, "{ 1, 2, 3 }");
1214}
1215
1216#undef EXPECT_PRINT_TO_STRING_
1217
1218TEST(UniversalTersePrintTest, WorksForNonReference) {
1219  ::std::stringstream ss;
1220  UniversalTersePrint(123, &ss);
1221  EXPECT_EQ("123", ss.str());
1222}
1223
1224TEST(UniversalTersePrintTest, WorksForReference) {
1225  const int& n = 123;
1226  ::std::stringstream ss;
1227  UniversalTersePrint(n, &ss);
1228  EXPECT_EQ("123", ss.str());
1229}
1230
1231TEST(UniversalTersePrintTest, WorksForCString) {
1232  const char* s1 = "abc";
1233  ::std::stringstream ss1;
1234  UniversalTersePrint(s1, &ss1);
1235  EXPECT_EQ("\"abc\"", ss1.str());
1236
1237  char* s2 = const_cast<char*>(s1);
1238  ::std::stringstream ss2;
1239  UniversalTersePrint(s2, &ss2);
1240  EXPECT_EQ("\"abc\"", ss2.str());
1241
1242  const char* s3 = NULL;
1243  ::std::stringstream ss3;
1244  UniversalTersePrint(s3, &ss3);
1245  EXPECT_EQ("NULL", ss3.str());
1246}
1247
1248TEST(UniversalPrintTest, WorksForNonReference) {
1249  ::std::stringstream ss;
1250  UniversalPrint(123, &ss);
1251  EXPECT_EQ("123", ss.str());
1252}
1253
1254TEST(UniversalPrintTest, WorksForReference) {
1255  const int& n = 123;
1256  ::std::stringstream ss;
1257  UniversalPrint(n, &ss);
1258  EXPECT_EQ("123", ss.str());
1259}
1260
1261TEST(UniversalPrintTest, WorksForCString) {
1262  const char* s1 = "abc";
1263  ::std::stringstream ss1;
1264  UniversalPrint(s1, &ss1);
1265  EXPECT_EQ(PrintPointer(s1) + " pointing to \"abc\"", string(ss1.str()));
1266
1267  char* s2 = const_cast<char*>(s1);
1268  ::std::stringstream ss2;
1269  UniversalPrint(s2, &ss2);
1270  EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", string(ss2.str()));
1271
1272  const char* s3 = NULL;
1273  ::std::stringstream ss3;
1274  UniversalPrint(s3, &ss3);
1275  EXPECT_EQ("NULL", ss3.str());
1276}
1277
1278
1279#if GTEST_HAS_TR1_TUPLE
1280
1281TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsEmptyTuple) {
1282  Strings result = UniversalTersePrintTupleFieldsToStrings(make_tuple());
1283  EXPECT_EQ(0u, result.size());
1284}
1285
1286TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsOneTuple) {
1287  Strings result = UniversalTersePrintTupleFieldsToStrings(make_tuple(1));
1288  ASSERT_EQ(1u, result.size());
1289  EXPECT_EQ("1", result[0]);
1290}
1291
1292TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsTwoTuple) {
1293  Strings result = UniversalTersePrintTupleFieldsToStrings(make_tuple(1, 'a'));
1294  ASSERT_EQ(2u, result.size());
1295  EXPECT_EQ("1", result[0]);
1296  EXPECT_EQ("'a' (97, 0x61)", result[1]);
1297}
1298
1299TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsTersely) {
1300  const int n = 1;
1301  Strings result = UniversalTersePrintTupleFieldsToStrings(
1302      tuple<const int&, const char*>(n, "a"));
1303  ASSERT_EQ(2u, result.size());
1304  EXPECT_EQ("1", result[0]);
1305  EXPECT_EQ("\"a\"", result[1]);
1306}
1307
1308#endif  // GTEST_HAS_TR1_TUPLE
1309
1310}  // namespace gtest_printers_test
1311}  // namespace testing
1312