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 implements a universal value printer that can print a
35// value of any type T:
36//
37// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
38//
39// A user can teach this function how to print a class type T by
40// defining either operator<<() or PrintTo() in the namespace that
41// defines T. More specifically, the FIRST defined function in the
42// following list will be used (assuming T is defined in namespace
43// foo):
44//
45// 1. foo::PrintTo(const T&, ostream*)
46// 2. operator<<(ostream&, const T&) defined in either foo or the
47// global namespace.
48//
49// If none of the above is defined, it will print the debug string of
50// the value if it is a protocol buffer, or print the raw bytes in the
51// value otherwise.
52//
53// To aid debugging: when T is a reference type, the address of the
54// value is also printed; when T is a (const) char pointer, both the
55// pointer value and the NUL-terminated string it points to are
56// printed.
57//
58// We also provide some convenient wrappers:
59//
60// // Prints a value to a string. For a (const or not) char
61// // pointer, the NUL-terminated string (but not the pointer) is
62// // printed.
63// std::string ::testing::PrintToString(const T& value);
64//
65// // Prints a value tersely: for a reference type, the referenced
66// // value (but not the address) is printed; for a (const or not) char
67// // pointer, the NUL-terminated string (but not the pointer) is
68// // printed.
69// void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
70//
71// // Prints value using the type inferred by the compiler. The difference
72// // from UniversalTersePrint() is that this function prints both the
73// // pointer and the NUL-terminated string for a (const or not) char pointer.
74// void ::testing::internal::UniversalPrint(const T& value, ostream*);
75//
76// // Prints the fields of a tuple tersely to a string vector, one
77// // element for each field. Tuple support must be enabled in
78// // gtest-port.h.
79// std::vector<string> UniversalTersePrintTupleFieldsToStrings(
80// const Tuple& value);
81//
82// Known limitation:
83//
84// The print primitives print the elements of an STL-style container
85// using the compiler-inferred type of *iter where iter is a
86// const_iterator of the container. When const_iterator is an input
87// iterator but not a forward iterator, this inferred type may not
88// match value_type, and the print output may be incorrect. In
89// practice, this is rarely a problem as for most containers
90// const_iterator is a forward iterator. We'll fix this if there's an
91// actual need for it. Note that this fix cannot rely on value_type
92// being defined as many user-defined container types don't have
93// value_type.
94
95#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
96#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
97
98#include <ostream> // NOLINT
99#include <sstream>
100#include <string>
101#include <utility>
102#include <vector>
103#include "gtest/internal/gtest-port.h"
104#include "gtest/internal/gtest-internal.h"
105
106#if GTEST_HAS_STD_TUPLE_
107# include <tuple>
108#endif
109
110namespace testing {
111
112// Definitions in the 'internal' and 'internal2' name spaces are
113// subject to change without notice. DO NOT USE THEM IN USER CODE!
114namespace internal2 {
115
116// Prints the given number of bytes in the given object to the given
117// ostream.
118GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
119 size_t count,
120 ::std::ostream* os);
121
122// For selecting which printer to use when a given type has neither <<
123// nor PrintTo().
124enum TypeKind {
125 kProtobuf, // a protobuf type
126 kConvertibleToInteger, // a type implicitly convertible to BiggestInt
127 // (e.g. a named or unnamed enum type)
128 kOtherType // anything else
129};
130
131// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
132// by the universal printer to print a value of type T when neither
133// operator<< nor PrintTo() is defined for T, where kTypeKind is the
134// "kind" of T as defined by enum TypeKind.
135template <typename T, TypeKind kTypeKind>
136class TypeWithoutFormatter {
137 public:
138 // This default version is called when kTypeKind is kOtherType.
139 static void PrintValue(const T& value, ::std::ostream* os) {
140 PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
141 sizeof(value), os);
142 }
143};
144
145// We print a protobuf using its ShortDebugString() when the string
146// doesn't exceed this many characters; otherwise we print it using
147// DebugString() for better readability.
148const size_t kProtobufOneLinerMaxLength = 50;
149
150template <typename T>
151class TypeWithoutFormatter<T, kProtobuf> {
152 public:
153 static void PrintValue(const T& value, ::std::ostream* os) {
154 const ::testing::internal::string short_str = value.ShortDebugString();
155 const ::testing::internal::string pretty_str =
156 short_str.length() <= kProtobufOneLinerMaxLength ?
157 short_str : ("\n" + value.DebugString());
158 *os << ("<" + pretty_str + ">");
159 }
160};
161
162template <typename T>
163class TypeWithoutFormatter<T, kConvertibleToInteger> {
164 public:
165 // Since T has no << operator or PrintTo() but can be implicitly
166 // converted to BiggestInt, we print it as a BiggestInt.
167 //
168 // Most likely T is an enum type (either named or unnamed), in which
169 // case printing it as an integer is the desired behavior. In case
170 // T is not an enum, printing it as an integer is the best we can do
171 // given that it has no user-defined printer.
172 static void PrintValue(const T& value, ::std::ostream* os) {
173 const internal::BiggestInt kBigInt = value;
174 *os << kBigInt;
175 }
176};
177
178// Prints the given value to the given ostream. If the value is a
179// protocol message, its debug string is printed; if it's an enum or
180// of a type implicitly convertible to BiggestInt, it's printed as an
181// integer; otherwise the bytes in the value are printed. This is
182// what UniversalPrinter<T>::Print() does when it knows nothing about
183// type T and T has neither << operator nor PrintTo().
184//
185// A user can override this behavior for a class type Foo by defining
186// a << operator in the namespace where Foo is defined.
187//
188// We put this operator in namespace 'internal2' instead of 'internal'
189// to simplify the implementation, as much code in 'internal' needs to
190// use << in STL, which would conflict with our own << were it defined
191// in 'internal'.
192//
193// Note that this operator<< takes a generic std::basic_ostream<Char,
194// CharTraits> type instead of the more restricted std::ostream. If
195// we define it to take an std::ostream instead, we'll get an
196// "ambiguous overloads" compiler error when trying to print a type
197// Foo that supports streaming to std::basic_ostream<Char,
198// CharTraits>, as the compiler cannot tell whether
199// operator<<(std::ostream&, const T&) or
200// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
201// specific.
202template <typename Char, typename CharTraits, typename T>
203::std::basic_ostream<Char, CharTraits>& operator<<(
204 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
205 TypeWithoutFormatter<T,
206 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
207 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
208 kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
209 return os;
210}
211
212} // namespace internal2
213} // namespace testing
214
215// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
216// magic needed for implementing UniversalPrinter won't work.
217namespace testing_internal {
218
219// Used to print a value that is not an STL-style container when the
220// user doesn't define PrintTo() for it.
221template <typename T>
222void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
223 // With the following statement, during unqualified name lookup,
224 // testing::internal2::operator<< appears as if it was declared in
225 // the nearest enclosing namespace that contains both
226 // ::testing_internal and ::testing::internal2, i.e. the global
227 // namespace. For more details, refer to the C++ Standard section
228 // 7.3.4-1 [namespace.udir]. This allows us to fall back onto
229 // testing::internal2::operator<< in case T doesn't come with a <<
230 // operator.
231 //
232 // We cannot write 'using ::testing::internal2::operator<<;', which
233 // gcc 3.3 fails to compile due to a compiler bug.
234 using namespace ::testing::internal2; // NOLINT
235
236 // Assuming T is defined in namespace foo, in the next statement,
237 // the compiler will consider all of:
238 //
239 // 1. foo::operator<< (thanks to Koenig look-up),
240 // 2. ::operator<< (as the current namespace is enclosed in ::),
241 // 3. testing::internal2::operator<< (thanks to the using statement above).
242 //
243 // The operator<< whose type matches T best will be picked.
244 //
245 // We deliberately allow #2 to be a candidate, as sometimes it's
246 // impossible to define #1 (e.g. when foo is ::std, defining
247 // anything in it is undefined behavior unless you are a compiler
248 // vendor.).
249 *os << value;
250}
251
252} // namespace testing_internal
253
254namespace testing {
255namespace internal {
256
257// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
258// value of type ToPrint that is an operand of a comparison assertion
259// (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in
260// the comparison, and is used to help determine the best way to
261// format the value. In particular, when the value is a C string
262// (char pointer) and the other operand is an STL string object, we
263// want to format the C string as a string, since we know it is
264// compared by value with the string object. If the value is a char
265// pointer but the other operand is not an STL string object, we don't
266// know whether the pointer is supposed to point to a NUL-terminated
267// string, and thus want to print it as a pointer to be safe.
268//
269// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
270
271// The default case.
272template <typename ToPrint, typename OtherOperand>
273class FormatForComparison {
274 public:
275 static ::std::string Format(const ToPrint& value) {
276 return ::testing::PrintToString(value);
277 }
278};
279
280// Array.
281template <typename ToPrint, size_t N, typename OtherOperand>
282class FormatForComparison<ToPrint[N], OtherOperand> {
283 public:
284 static ::std::string Format(const ToPrint* value) {
285 return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
286 }
287};
288
289// By default, print C string as pointers to be safe, as we don't know
290// whether they actually point to a NUL-terminated string.
291
292#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \
293 template <typename OtherOperand> \
294 class FormatForComparison<CharType*, OtherOperand> { \
295 public: \
296 static ::std::string Format(CharType* value) { \
297 return ::testing::PrintToString(static_cast<const void*>(value)); \
298 } \
299 }
300
301GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
302GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
303GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
304GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
305
306#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
307
308// If a C string is compared with an STL string object, we know it's meant
309// to point to a NUL-terminated string, and thus can print it as a string.
310
311#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
312 template <> \
313 class FormatForComparison<CharType*, OtherStringType> { \
314 public: \
315 static ::std::string Format(CharType* value) { \
316 return ::testing::PrintToString(value); \
317 } \
318 }
319
320GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
321GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
322
323#if GTEST_HAS_GLOBAL_STRING
324GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
325GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
326#endif
327
328#if GTEST_HAS_GLOBAL_WSTRING
329GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
330GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
331#endif
332
333#if GTEST_HAS_STD_WSTRING
334GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
335GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
336#endif
337
338#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
339
340// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
341// operand to be used in a failure message. The type (but not value)
342// of the other operand may affect the format. This allows us to
343// print a char* as a raw pointer when it is compared against another
344// char* or void*, and print it as a C string when it is compared
345// against an std::string object, for example.
346//
347// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
348template <typename T1, typename T2>
349std::string FormatForComparisonFailureMessage(
350 const T1& value, const T2& /* other_operand */) {
351 return FormatForComparison<T1, T2>::Format(value);
352}
353
354// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
355// value to the given ostream. The caller must ensure that
356// 'ostream_ptr' is not NULL, or the behavior is undefined.
357//
358// We define UniversalPrinter as a class template (as opposed to a
359// function template), as we need to partially specialize it for
360// reference types, which cannot be done with function templates.
361template <typename T>
362class UniversalPrinter;
363
364template <typename T>
365void UniversalPrint(const T& value, ::std::ostream* os);
366
367// Used to print an STL-style container when the user doesn't define
368// a PrintTo() for it.
369template <typename C>
370void DefaultPrintTo(IsContainer /* dummy */,
371 false_type /* is not a pointer */,
372 const C& container, ::std::ostream* os) {
373 const size_t kMaxCount = 32; // The maximum number of elements to print.
374 *os << '{';
375 size_t count = 0;
376 for (typename C::const_iterator it = container.begin();
377 it != container.end(); ++it, ++count) {
378 if (count > 0) {
379 *os << ',';
380 if (count == kMaxCount) { // Enough has been printed.
381 *os << " ...";
382 break;
383 }
384 }
385 *os << ' ';
386 // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
387 // handle *it being a native array.
388 internal::UniversalPrint(*it, os);
389 }
390
391 if (count > 0) {
392 *os << ' ';
393 }
394 *os << '}';
395}
396
397// Used to print a pointer that is neither a char pointer nor a member
398// pointer, when the user doesn't define PrintTo() for it. (A member
399// variable pointer or member function pointer doesn't really point to
400// a location in the address space. Their representation is
401// implementation-defined. Therefore they will be printed as raw
402// bytes.)
403template <typename T>
404void DefaultPrintTo(IsNotContainer /* dummy */,
405 true_type /* is a pointer */,
406 T* p, ::std::ostream* os) {
407 if (p == NULL) {
408 *os << "NULL";
409 } else {
410 // C++ doesn't allow casting from a function pointer to any object
411 // pointer.
412 //
413 // IsTrue() silences warnings: "Condition is always true",
414 // "unreachable code".
415 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
416 // T is not a function type. We just call << to print p,
417 // relying on ADL to pick up user-defined << for their pointer
418 // types, if any.
419 *os << p;
420 } else {
421 // T is a function type, so '*os << p' doesn't do what we want
422 // (it just prints p as bool). We want to print p as a const
423 // void*. However, we cannot cast it to const void* directly,
424 // even using reinterpret_cast, as earlier versions of gcc
425 // (e.g. 3.4.5) cannot compile the cast when p is a function
426 // pointer. Casting to UInt64 first solves the problem.
427 *os << reinterpret_cast<const void*>(
428 reinterpret_cast<internal::UInt64>(p));
429 }
430 }
431}
432
433// Used to print a non-container, non-pointer value when the user
434// doesn't define PrintTo() for it.
435template <typename T>
436void DefaultPrintTo(IsNotContainer /* dummy */,
437 false_type /* is not a pointer */,
438 const T& value, ::std::ostream* os) {
439 ::testing_internal::DefaultPrintNonContainerTo(value, os);
440}
441
442// Prints the given value using the << operator if it has one;
443// otherwise prints the bytes in it. This is what
444// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
445// or overloaded for type T.
446//
447// A user can override this behavior for a class type Foo by defining
448// an overload of PrintTo() in the namespace where Foo is defined. We
449// give the user this option as sometimes defining a << operator for
450// Foo is not desirable (e.g. the coding style may prevent doing it,
451// or there is already a << operator but it doesn't do what the user
452// wants).
453template <typename T>
454void PrintTo(const T& value, ::std::ostream* os) {
455 // DefaultPrintTo() is overloaded. The type of its first two
456 // arguments determine which version will be picked. If T is an
457 // STL-style container, the version for container will be called; if
458 // T is a pointer, the pointer version will be called; otherwise the
459 // generic version will be called.
460 //
461 // Note that we check for container types here, prior to we check
462 // for protocol message types in our operator<<. The rationale is:
463 //
464 // For protocol messages, we want to give people a chance to
465 // override Google Mock's format by defining a PrintTo() or
466 // operator<<. For STL containers, other formats can be
467 // incompatible with Google Mock's format for the container
468 // elements; therefore we check for container types here to ensure
469 // that our format is used.
470 //
471 // The second argument of DefaultPrintTo() is needed to bypass a bug
472 // in Symbian's C++ compiler that prevents it from picking the right
473 // overload between:
474 //
475 // PrintTo(const T& x, ...);
476 // PrintTo(T* x, ...);
477 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
478}
479
480// The following list of PrintTo() overloads tells
481// UniversalPrinter<T>::Print() how to print standard types (built-in
482// types, strings, plain arrays, and pointers).
483
484// Overloads for various char types.
485GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
486GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
487inline void PrintTo(char c, ::std::ostream* os) {
488 // When printing a plain char, we always treat it as unsigned. This
489 // way, the output won't be affected by whether the compiler thinks
490 // char is signed or not.
491 PrintTo(static_cast<unsigned char>(c), os);
492}
493
494// Overloads for other simple built-in types.
495inline void PrintTo(bool x, ::std::ostream* os) {
496 *os << (x ? "true" : "false");
497}
498
499// Overload for wchar_t type.
500// Prints a wchar_t as a symbol if it is printable or as its internal
501// code otherwise and also as its decimal code (except for L'\0').
502// The L'\0' char is printed as "L'\\0'". The decimal code is printed
503// as signed integer when wchar_t is implemented by the compiler
504// as a signed type and is printed as an unsigned integer when wchar_t
505// is implemented as an unsigned type.
506GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
507
508// Overloads for C strings.
509GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
510inline void PrintTo(char* s, ::std::ostream* os) {
511 PrintTo(ImplicitCast_<const char*>(s), os);
512}
513
514// signed/unsigned char is often used for representing binary data, so
515// we print pointers to it as void* to be safe.
516inline void PrintTo(const signed char* s, ::std::ostream* os) {
517 PrintTo(ImplicitCast_<const void*>(s), os);
518}
519inline void PrintTo(signed char* s, ::std::ostream* os) {
520 PrintTo(ImplicitCast_<const void*>(s), os);
521}
522inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
523 PrintTo(ImplicitCast_<const void*>(s), os);
524}
525inline void PrintTo(unsigned char* s, ::std::ostream* os) {
526 PrintTo(ImplicitCast_<const void*>(s), os);
527}
528
529// MSVC can be configured to define wchar_t as a typedef of unsigned
530// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
531// type. When wchar_t is a typedef, defining an overload for const
532// wchar_t* would cause unsigned short* be printed as a wide string,
533// possibly causing invalid memory accesses.
534#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
535// Overloads for wide C strings
536GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
537inline void PrintTo(wchar_t* s, ::std::ostream* os) {
538 PrintTo(ImplicitCast_<const wchar_t*>(s), os);
539}
540#endif
541
542// Overload for C arrays. Multi-dimensional arrays are printed
543// properly.
544
545// Prints the given number of elements in an array, without printing
546// the curly braces.
547template <typename T>
548void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
549 UniversalPrint(a[0], os);
550 for (size_t i = 1; i != count; i++) {
551 *os << ", ";
552 UniversalPrint(a[i], os);
553 }
554}
555
556// Overloads for ::string and ::std::string.
557#if GTEST_HAS_GLOBAL_STRING
558GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
559inline void PrintTo(const ::string& s, ::std::ostream* os) {
560 PrintStringTo(s, os);
561}
562#endif // GTEST_HAS_GLOBAL_STRING
563
564GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
565inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
566 PrintStringTo(s, os);
567}
568
569// Overloads for ::wstring and ::std::wstring.
570#if GTEST_HAS_GLOBAL_WSTRING
571GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
572inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
573 PrintWideStringTo(s, os);
574}
575#endif // GTEST_HAS_GLOBAL_WSTRING
576
577#if GTEST_HAS_STD_WSTRING
578GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
579inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
580 PrintWideStringTo(s, os);
581}
582#endif // GTEST_HAS_STD_WSTRING
583
584#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
585// Helper function for printing a tuple. T must be instantiated with
586// a tuple type.
587template <typename T>
588void PrintTupleTo(const T& t, ::std::ostream* os);
589#endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
590
591#if GTEST_HAS_TR1_TUPLE
592// Overload for ::std::tr1::tuple. Needed for printing function arguments,
593// which are packed as tuples.
594
595// Overloaded PrintTo() for tuples of various arities. We support
596// tuples of up-to 10 fields. The following implementation works
597// regardless of whether tr1::tuple is implemented using the
598// non-standard variadic template feature or not.
599
600inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
601 PrintTupleTo(t, os);
602}
603
604template <typename T1>
605void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
606 PrintTupleTo(t, os);
607}
608
609template <typename T1, typename T2>
610void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
611 PrintTupleTo(t, os);
612}
613
614template <typename T1, typename T2, typename T3>
615void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
616 PrintTupleTo(t, os);
617}
618
619template <typename T1, typename T2, typename T3, typename T4>
620void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
621 PrintTupleTo(t, os);
622}
623
624template <typename T1, typename T2, typename T3, typename T4, typename T5>
625void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
626 ::std::ostream* os) {
627 PrintTupleTo(t, os);
628}
629
630template <typename T1, typename T2, typename T3, typename T4, typename T5,
631 typename T6>
632void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
633 ::std::ostream* os) {
634 PrintTupleTo(t, os);
635}
636
637template <typename T1, typename T2, typename T3, typename T4, typename T5,
638 typename T6, typename T7>
639void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
640 ::std::ostream* os) {
641 PrintTupleTo(t, os);
642}
643
644template <typename T1, typename T2, typename T3, typename T4, typename T5,
645 typename T6, typename T7, typename T8>
646void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
647 ::std::ostream* os) {
648 PrintTupleTo(t, os);
649}
650
651template <typename T1, typename T2, typename T3, typename T4, typename T5,
652 typename T6, typename T7, typename T8, typename T9>
653void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
654 ::std::ostream* os) {
655 PrintTupleTo(t, os);
656}
657
658template <typename T1, typename T2, typename T3, typename T4, typename T5,
659 typename T6, typename T7, typename T8, typename T9, typename T10>
660void PrintTo(
661 const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
662 ::std::ostream* os) {
663 PrintTupleTo(t, os);
664}
665#endif // GTEST_HAS_TR1_TUPLE
666
667#if GTEST_HAS_STD_TUPLE_
668template <typename... Types>
669void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
670 PrintTupleTo(t, os);
671}
672#endif // GTEST_HAS_STD_TUPLE_
673
674// Overload for std::pair.
675template <typename T1, typename T2>
676void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
677 *os << '(';
678 // We cannot use UniversalPrint(value.first, os) here, as T1 may be
679 // a reference type. The same for printing value.second.
680 UniversalPrinter<T1>::Print(value.first, os);
681 *os << ", ";
682 UniversalPrinter<T2>::Print(value.second, os);
683 *os << ')';
684}
685
686// Implements printing a non-reference type T by letting the compiler
687// pick the right overload of PrintTo() for T.
688template <typename T>
689class UniversalPrinter {
690 public:
691 // MSVC warns about adding const to a function type, so we want to
692 // disable the warning.
693 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
694
695 // Note: we deliberately don't call this PrintTo(), as that name
696 // conflicts with ::testing::internal::PrintTo in the body of the
697 // function.
698 static void Print(const T& value, ::std::ostream* os) {
699 // By default, ::testing::internal::PrintTo() is used for printing
700 // the value.
701 //
702 // Thanks to Koenig look-up, if T is a class and has its own
703 // PrintTo() function defined in its namespace, that function will
704 // be visible here. Since it is more specific than the generic ones
705 // in ::testing::internal, it will be picked by the compiler in the
706 // following statement - exactly what we want.
707 PrintTo(value, os);
708 }
709
710 GTEST_DISABLE_MSC_WARNINGS_POP_()
711};
712
713// UniversalPrintArray(begin, len, os) prints an array of 'len'
714// elements, starting at address 'begin'.
715template <typename T>
716void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
717 if (len == 0) {
718 *os << "{}";
719 } else {
720 *os << "{ ";
721 const size_t kThreshold = 18;
722 const size_t kChunkSize = 8;
723 // If the array has more than kThreshold elements, we'll have to
724 // omit some details by printing only the first and the last
725 // kChunkSize elements.
726 // TODO(wan@google.com): let the user control the threshold using a flag.
727 if (len <= kThreshold) {
728 PrintRawArrayTo(begin, len, os);
729 } else {
730 PrintRawArrayTo(begin, kChunkSize, os);
731 *os << ", ..., ";
732 PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
733 }
734 *os << " }";
735 }
736}
737// This overload prints a (const) char array compactly.
738GTEST_API_ void UniversalPrintArray(
739 const char* begin, size_t len, ::std::ostream* os);
740
741// This overload prints a (const) wchar_t array compactly.
742GTEST_API_ void UniversalPrintArray(
743 const wchar_t* begin, size_t len, ::std::ostream* os);
744
745// Implements printing an array type T[N].
746template <typename T, size_t N>
747class UniversalPrinter<T[N]> {
748 public:
749 // Prints the given array, omitting some elements when there are too
750 // many.
751 static void Print(const T (&a)[N], ::std::ostream* os) {
752 UniversalPrintArray(a, N, os);
753 }
754};
755
756// Implements printing a reference type T&.
757template <typename T>
758class UniversalPrinter<T&> {
759 public:
760 // MSVC warns about adding const to a function type, so we want to
761 // disable the warning.
762 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
763
764 static void Print(const T& value, ::std::ostream* os) {
765 // Prints the address of the value. We use reinterpret_cast here
766 // as static_cast doesn't compile when T is a function type.
767 *os << "@" << reinterpret_cast<const void*>(&value) << " ";
768
769 // Then prints the value itself.
770 UniversalPrint(value, os);
771 }
772
773 GTEST_DISABLE_MSC_WARNINGS_POP_()
774};
775
776// Prints a value tersely: for a reference type, the referenced value
777// (but not the address) is printed; for a (const) char pointer, the
778// NUL-terminated string (but not the pointer) is printed.
779
780template <typename T>
781class UniversalTersePrinter {
782 public:
783 static void Print(const T& value, ::std::ostream* os) {
784 UniversalPrint(value, os);
785 }
786};
787template <typename T>
788class UniversalTersePrinter<T&> {
789 public:
790 static void Print(const T& value, ::std::ostream* os) {
791 UniversalPrint(value, os);
792 }
793};
794template <typename T, size_t N>
795class UniversalTersePrinter<T[N]> {
796 public:
797 static void Print(const T (&value)[N], ::std::ostream* os) {
798 UniversalPrinter<T[N]>::Print(value, os);
799 }
800};
801template <>
802class UniversalTersePrinter<const char*> {
803 public:
804 static void Print(const char* str, ::std::ostream* os) {
805 if (str == NULL) {
806 *os << "NULL";
807 } else {
808 UniversalPrint(string(str), os);
809 }
810 }
811};
812template <>
813class UniversalTersePrinter<char*> {
814 public:
815 static void Print(char* str, ::std::ostream* os) {
816 UniversalTersePrinter<const char*>::Print(str, os);
817 }
818};
819
820#if GTEST_HAS_STD_WSTRING
821template <>
822class UniversalTersePrinter<const wchar_t*> {
823 public:
824 static void Print(const wchar_t* str, ::std::ostream* os) {
825 if (str == NULL) {
826 *os << "NULL";
827 } else {
828 UniversalPrint(::std::wstring(str), os);
829 }
830 }
831};
832#endif
833
834template <>
835class UniversalTersePrinter<wchar_t*> {
836 public:
837 static void Print(wchar_t* str, ::std::ostream* os) {
838 UniversalTersePrinter<const wchar_t*>::Print(str, os);
839 }
840};
841
842template <typename T>
843void UniversalTersePrint(const T& value, ::std::ostream* os) {
844 UniversalTersePrinter<T>::Print(value, os);
845}
846
847// Prints a value using the type inferred by the compiler. The
848// difference between this and UniversalTersePrint() is that for a
849// (const) char pointer, this prints both the pointer and the
850// NUL-terminated string.
851template <typename T>
852void UniversalPrint(const T& value, ::std::ostream* os) {
853 // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
854 // UniversalPrinter with T directly.
855 typedef T T1;
856 UniversalPrinter<T1>::Print(value, os);
857}
858
859typedef ::std::vector<string> Strings;
860
861// TuplePolicy<TupleT> must provide:
862// - tuple_size
863// size of tuple TupleT.
864// - get<size_t I>(const TupleT& t)
865// static function extracting element I of tuple TupleT.
866// - tuple_element<size_t I>::type
867// type of element I of tuple TupleT.
868template <typename TupleT>
869struct TuplePolicy;
870
871#if GTEST_HAS_TR1_TUPLE
872template <typename TupleT>
873struct TuplePolicy {
874 typedef TupleT Tuple;
875 static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
876
877 template <size_t I>
878 struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};
879
880 template <size_t I>
881 static typename AddReference<
882 const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
883 const Tuple& tuple) {
884 return ::std::tr1::get<I>(tuple);
885 }
886};
887template <typename TupleT>
888const size_t TuplePolicy<TupleT>::tuple_size;
889#endif // GTEST_HAS_TR1_TUPLE
890
891#if GTEST_HAS_STD_TUPLE_
892template <typename... Types>
893struct TuplePolicy< ::std::tuple<Types...> > {
894 typedef ::std::tuple<Types...> Tuple;
895 static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
896
897 template <size_t I>
898 struct tuple_element : ::std::tuple_element<I, Tuple> {};
899
900 template <size_t I>
901 static const typename ::std::tuple_element<I, Tuple>::type& get(
902 const Tuple& tuple) {
903 return ::std::get<I>(tuple);
904 }
905};
906template <typename... Types>
907const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
908#endif // GTEST_HAS_STD_TUPLE_
909
910#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
911// This helper template allows PrintTo() for tuples and
912// UniversalTersePrintTupleFieldsToStrings() to be defined by
913// induction on the number of tuple fields. The idea is that
914// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
915// fields in tuple t, and can be defined in terms of
916// TuplePrefixPrinter<N - 1>.
917//
918// The inductive case.
919template <size_t N>
920struct TuplePrefixPrinter {
921 // Prints the first N fields of a tuple.
922 template <typename Tuple>
923 static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
924 TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
925 GTEST_INTENTIONAL_CONST_COND_PUSH_()
926 if (N > 1) {
927 GTEST_INTENTIONAL_CONST_COND_POP_()
928 *os << ", ";
929 }
930 UniversalPrinter<
931 typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
932 ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
933 }
934
935 // Tersely prints the first N fields of a tuple to a string vector,
936 // one element for each field.
937 template <typename Tuple>
938 static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
939 TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
940 ::std::stringstream ss;
941 UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
942 strings->push_back(ss.str());
943 }
944};
945
946// Base case.
947template <>
948struct TuplePrefixPrinter<0> {
949 template <typename Tuple>
950 static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
951
952 template <typename Tuple>
953 static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
954};
955
956// Helper function for printing a tuple.
957// Tuple must be either std::tr1::tuple or std::tuple type.
958template <typename Tuple>
959void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
960 *os << "(";
961 TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t, os);
962 *os << ")";
963}
964
965// Prints the fields of a tuple tersely to a string vector, one
966// element for each field. See the comment before
967// UniversalTersePrint() for how we define "tersely".
968template <typename Tuple>
969Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
970 Strings result;
971 TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
972 TersePrintPrefixToStrings(value, &result);
973 return result;
974}
975#endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
976
977} // namespace internal
978
979template <typename T>
980::std::string PrintToString(const T& value) {
981 ::std::stringstream ss;
982 internal::UniversalTersePrinter<T>::Print(value, &ss);
983 return ss.str();
984}
985
986} // namespace testing
987
988// Include any custom printer added by the local installation.
989// We must include this header at the end to make sure it can use the
990// declarations from this file.
991#include "gtest/internal/custom/gtest-printers.h"
992
993#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
994