1 // Copyright 2007, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
30 // Author: wan@google.com (Zhanyong Wan)
32 // Google Test - The Google C++ Testing Framework
34 // This file implements a universal value printer that can print a
35 // value of any type T:
37 // void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
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
45 // 1. foo::PrintTo(const T&, ostream*)
46 // 2. operator<<(ostream&, const T&) defined in either foo or the
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
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
58 // We also provide some convenient wrappers:
60 // // Prints a value to a string. For a (const or not) char
61 // // pointer, the NUL-terminated string (but not the pointer) is
63 // std::string ::testing::PrintToString(const T& value);
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
69 // void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
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*);
76 // // Prints the fields of a tuple tersely to a string vector, one
77 // // element for each field. Tuple support must be enabled in
79 // std::vector<string> UniversalTersePrintTupleFieldsToStrings(
80 // const Tuple& value);
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
95 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
96 #define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
98 #include <ostream> // NOLINT
103 #include "gtest/internal/gtest-port.h"
104 #include "gtest/internal/gtest-internal.h"
106 #if GTEST_HAS_STD_TUPLE_
112 // Definitions in the 'internal' and 'internal2' name spaces are
113 // subject to change without notice. DO NOT USE THEM IN USER CODE!
114 namespace internal2
{
116 // Prints the given number of bytes in the given object to the given
118 GTEST_API_
void PrintBytesInObjectTo(const unsigned char* obj_bytes
,
122 // For selecting which printer to use when a given type has neither <<
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
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.
135 template <typename T
, TypeKind kTypeKind
>
136 class TypeWithoutFormatter
{
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
),
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.
148 const size_t kProtobufOneLinerMaxLength
= 50;
150 template <typename T
>
151 class TypeWithoutFormatter
<T
, kProtobuf
> {
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
+ ">");
162 template <typename T
>
163 class TypeWithoutFormatter
<T
, kConvertibleToInteger
> {
165 // Since T has no << operator or PrintTo() but can be implicitly
166 // converted to BiggestInt, we print it as a BiggestInt.
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
;
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().
185 // A user can override this behavior for a class type Foo by defining
186 // a << operator in the namespace where Foo is defined.
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
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
202 template <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
);
212 } // namespace internal2
213 } // namespace testing
215 // This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
216 // magic needed for implementing UniversalPrinter won't work.
217 namespace testing_internal
{
219 // Used to print a value that is not an STL-style container when the
220 // user doesn't define PrintTo() for it.
221 template <typename T
>
222 void 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 <<
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
236 // Assuming T is defined in namespace foo, in the next statement,
237 // the compiler will consider all of:
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).
243 // The operator<< whose type matches T best will be picked.
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
252 } // namespace testing_internal
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.
269 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
272 template <typename ToPrint
, typename OtherOperand
>
273 class FormatForComparison
{
275 static ::std::string
Format(const ToPrint
& value
) {
276 return ::testing::PrintToString(value
);
281 template <typename ToPrint
, size_t N
, typename OtherOperand
>
282 class FormatForComparison
<ToPrint
[N
], OtherOperand
> {
284 static ::std::string
Format(const ToPrint
* value
) {
285 return FormatForComparison
<const ToPrint
*, OtherOperand
>::Format(value
);
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.
292 #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \
293 template <typename OtherOperand> \
294 class FormatForComparison<CharType*, OtherOperand> { \
296 static ::std::string Format(CharType* value) { \
297 return ::testing::PrintToString(static_cast<const void*>(value)); \
301 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
302 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
303 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
304 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
306 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
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.
311 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
313 class FormatForComparison<CharType*, OtherStringType> { \
315 static ::std::string Format(CharType* value) { \
316 return ::testing::PrintToString(value); \
320 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string
);
321 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string
);
323 #if GTEST_HAS_GLOBAL_STRING
324 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string
);
325 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string
);
328 #if GTEST_HAS_GLOBAL_WSTRING
329 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring
);
330 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring
);
333 #if GTEST_HAS_STD_WSTRING
334 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring
);
335 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring
);
338 #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
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.
347 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
348 template <typename T1
, typename T2
>
349 std::string
FormatForComparisonFailureMessage(
350 const T1
& value
, const T2
& /* other_operand */) {
351 return FormatForComparison
<T1
, T2
>::Format(value
);
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.
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.
361 template <typename T
>
362 class UniversalPrinter
;
364 template <typename T
>
365 void UniversalPrint(const T
& value
, ::std::ostream
* os
);
367 // Used to print an STL-style container when the user doesn't define
368 // a PrintTo() for it.
369 template <typename C
>
370 void 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.
376 for (typename
C::const_iterator it
= container
.begin();
377 it
!= container
.end(); ++it
, ++count
) {
380 if (count
== kMaxCount
) { // Enough has been printed.
386 // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
387 // handle *it being a native array.
388 internal::UniversalPrint(*it
, os
);
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
403 template <typename T
>
404 void DefaultPrintTo(IsNotContainer
/* dummy */,
405 true_type
/* is a pointer */,
406 T
* p
, ::std::ostream
* os
) {
410 // C++ doesn't allow casting from a function pointer to any object
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
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
));
433 // Used to print a non-container, non-pointer value when the user
434 // doesn't define PrintTo() for it.
435 template <typename T
>
436 void DefaultPrintTo(IsNotContainer
/* dummy */,
437 false_type
/* is not a pointer */,
438 const T
& value
, ::std::ostream
* os
) {
439 ::testing_internal::DefaultPrintNonContainerTo(value
, os
);
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.
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
453 template <typename T
>
454 void 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.
461 // Note that we check for container types here, prior to we check
462 // for protocol message types in our operator<<. The rationale is:
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.
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
475 // PrintTo(const T& x, ...);
476 // PrintTo(T* x, ...);
477 DefaultPrintTo(IsContainerTest
<T
>(0), is_pointer
<T
>(), value
, os
);
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).
484 // Overloads for various char types.
485 GTEST_API_
void PrintTo(unsigned char c
, ::std::ostream
* os
);
486 GTEST_API_
void PrintTo(signed char c
, ::std::ostream
* os
);
487 inline 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
);
494 // Overloads for other simple built-in types.
495 inline void PrintTo(bool x
, ::std::ostream
* os
) {
496 *os
<< (x
? "true" : "false");
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.
506 GTEST_API_
void PrintTo(wchar_t wc
, ::std::ostream
* os
);
508 // Overloads for C strings.
509 GTEST_API_
void PrintTo(const char* s
, ::std::ostream
* os
);
510 inline void PrintTo(char* s
, ::std::ostream
* os
) {
511 PrintTo(ImplicitCast_
<const char*>(s
), os
);
514 // signed/unsigned char is often used for representing binary data, so
515 // we print pointers to it as void* to be safe.
516 inline void PrintTo(const signed char* s
, ::std::ostream
* os
) {
517 PrintTo(ImplicitCast_
<const void*>(s
), os
);
519 inline void PrintTo(signed char* s
, ::std::ostream
* os
) {
520 PrintTo(ImplicitCast_
<const void*>(s
), os
);
522 inline void PrintTo(const unsigned char* s
, ::std::ostream
* os
) {
523 PrintTo(ImplicitCast_
<const void*>(s
), os
);
525 inline void PrintTo(unsigned char* s
, ::std::ostream
* os
) {
526 PrintTo(ImplicitCast_
<const void*>(s
), os
);
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
536 GTEST_API_
void PrintTo(const wchar_t* s
, ::std::ostream
* os
);
537 inline void PrintTo(wchar_t* s
, ::std::ostream
* os
) {
538 PrintTo(ImplicitCast_
<const wchar_t*>(s
), os
);
542 // Overload for C arrays. Multi-dimensional arrays are printed
545 // Prints the given number of elements in an array, without printing
547 template <typename T
>
548 void PrintRawArrayTo(const T a
[], size_t count
, ::std::ostream
* os
) {
549 UniversalPrint(a
[0], os
);
550 for (size_t i
= 1; i
!= count
; i
++) {
552 UniversalPrint(a
[i
], os
);
556 // Overloads for ::string and ::std::string.
557 #if GTEST_HAS_GLOBAL_STRING
558 GTEST_API_
void PrintStringTo(const ::string
&s
, ::std::ostream
* os
);
559 inline void PrintTo(const ::string
& s
, ::std::ostream
* os
) {
560 PrintStringTo(s
, os
);
562 #endif // GTEST_HAS_GLOBAL_STRING
564 GTEST_API_
void PrintStringTo(const ::std::string
&s
, ::std::ostream
* os
);
565 inline void PrintTo(const ::std::string
& s
, ::std::ostream
* os
) {
566 PrintStringTo(s
, os
);
569 // Overloads for ::wstring and ::std::wstring.
570 #if GTEST_HAS_GLOBAL_WSTRING
571 GTEST_API_
void PrintWideStringTo(const ::wstring
&s
, ::std::ostream
* os
);
572 inline void PrintTo(const ::wstring
& s
, ::std::ostream
* os
) {
573 PrintWideStringTo(s
, os
);
575 #endif // GTEST_HAS_GLOBAL_WSTRING
577 #if GTEST_HAS_STD_WSTRING
578 GTEST_API_
void PrintWideStringTo(const ::std::wstring
&s
, ::std::ostream
* os
);
579 inline void PrintTo(const ::std::wstring
& s
, ::std::ostream
* os
) {
580 PrintWideStringTo(s
, os
);
582 #endif // GTEST_HAS_STD_WSTRING
584 #if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
585 // Helper function for printing a tuple. T must be instantiated with
587 template <typename T
>
588 void PrintTupleTo(const T
& t
, ::std::ostream
* os
);
589 #endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
591 #if GTEST_HAS_TR1_TUPLE
592 // Overload for ::std::tr1::tuple. Needed for printing function arguments,
593 // which are packed as tuples.
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.
600 inline void PrintTo(const ::std::tr1::tuple
<>& t
, ::std::ostream
* os
) {
604 template <typename T1
>
605 void PrintTo(const ::std::tr1::tuple
<T1
>& t
, ::std::ostream
* os
) {
609 template <typename T1
, typename T2
>
610 void PrintTo(const ::std::tr1::tuple
<T1
, T2
>& t
, ::std::ostream
* os
) {
614 template <typename T1
, typename T2
, typename T3
>
615 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
>& t
, ::std::ostream
* os
) {
619 template <typename T1
, typename T2
, typename T3
, typename T4
>
620 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
>& t
, ::std::ostream
* os
) {
624 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
>
625 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
>& t
,
626 ::std::ostream
* os
) {
630 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
,
632 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
, T6
>& t
,
633 ::std::ostream
* os
) {
637 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
,
638 typename T6
, typename T7
>
639 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
, T6
, T7
>& t
,
640 ::std::ostream
* os
) {
644 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
,
645 typename T6
, typename T7
, typename T8
>
646 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
, T6
, T7
, T8
>& t
,
647 ::std::ostream
* os
) {
651 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
,
652 typename T6
, typename T7
, typename T8
, typename T9
>
653 void PrintTo(const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
, T6
, T7
, T8
, T9
>& t
,
654 ::std::ostream
* os
) {
658 template <typename T1
, typename T2
, typename T3
, typename T4
, typename T5
,
659 typename T6
, typename T7
, typename T8
, typename T9
, typename T10
>
661 const ::std::tr1::tuple
<T1
, T2
, T3
, T4
, T5
, T6
, T7
, T8
, T9
, T10
>& t
,
662 ::std::ostream
* os
) {
665 #endif // GTEST_HAS_TR1_TUPLE
667 #if GTEST_HAS_STD_TUPLE_
668 template <typename
... Types
>
669 void PrintTo(const ::std::tuple
<Types
...>& t
, ::std::ostream
* os
) {
672 #endif // GTEST_HAS_STD_TUPLE_
674 // Overload for std::pair.
675 template <typename T1
, typename T2
>
676 void PrintTo(const ::std::pair
<T1
, T2
>& value
, ::std::ostream
* 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
);
682 UniversalPrinter
<T2
>::Print(value
.second
, os
);
686 // Implements printing a non-reference type T by letting the compiler
687 // pick the right overload of PrintTo() for T.
688 template <typename T
>
689 class UniversalPrinter
{
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)
695 // Note: we deliberately don't call this PrintTo(), as that name
696 // conflicts with ::testing::internal::PrintTo in the body of the
698 static void Print(const T
& value
, ::std::ostream
* os
) {
699 // By default, ::testing::internal::PrintTo() is used for printing
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.
710 GTEST_DISABLE_MSC_WARNINGS_POP_()
713 // UniversalPrintArray(begin, len, os) prints an array of 'len'
714 // elements, starting at address 'begin'.
715 template <typename T
>
716 void UniversalPrintArray(const T
* begin
, size_t len
, ::std::ostream
* 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
);
730 PrintRawArrayTo(begin
, kChunkSize
, os
);
732 PrintRawArrayTo(begin
+ len
- kChunkSize
, kChunkSize
, os
);
737 // This overload prints a (const) char array compactly.
738 GTEST_API_
void UniversalPrintArray(
739 const char* begin
, size_t len
, ::std::ostream
* os
);
741 // This overload prints a (const) wchar_t array compactly.
742 GTEST_API_
void UniversalPrintArray(
743 const wchar_t* begin
, size_t len
, ::std::ostream
* os
);
745 // Implements printing an array type T[N].
746 template <typename T
, size_t N
>
747 class UniversalPrinter
<T
[N
]> {
749 // Prints the given array, omitting some elements when there are too
751 static void Print(const T (&a
)[N
], ::std::ostream
* os
) {
752 UniversalPrintArray(a
, N
, os
);
756 // Implements printing a reference type T&.
757 template <typename T
>
758 class UniversalPrinter
<T
&> {
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)
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
) << " ";
769 // Then prints the value itself.
770 UniversalPrint(value
, os
);
773 GTEST_DISABLE_MSC_WARNINGS_POP_()
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.
780 template <typename T
>
781 class UniversalTersePrinter
{
783 static void Print(const T
& value
, ::std::ostream
* os
) {
784 UniversalPrint(value
, os
);
787 template <typename T
>
788 class UniversalTersePrinter
<T
&> {
790 static void Print(const T
& value
, ::std::ostream
* os
) {
791 UniversalPrint(value
, os
);
794 template <typename T
, size_t N
>
795 class UniversalTersePrinter
<T
[N
]> {
797 static void Print(const T (&value
)[N
], ::std::ostream
* os
) {
798 UniversalPrinter
<T
[N
]>::Print(value
, os
);
802 class UniversalTersePrinter
<const char*> {
804 static void Print(const char* str
, ::std::ostream
* os
) {
808 UniversalPrint(string(str
), os
);
813 class UniversalTersePrinter
<char*> {
815 static void Print(char* str
, ::std::ostream
* os
) {
816 UniversalTersePrinter
<const char*>::Print(str
, os
);
820 #if GTEST_HAS_STD_WSTRING
822 class UniversalTersePrinter
<const wchar_t*> {
824 static void Print(const wchar_t* str
, ::std::ostream
* os
) {
828 UniversalPrint(::std::wstring(str
), os
);
835 class UniversalTersePrinter
<wchar_t*> {
837 static void Print(wchar_t* str
, ::std::ostream
* os
) {
838 UniversalTersePrinter
<const wchar_t*>::Print(str
, os
);
842 template <typename T
>
843 void UniversalTersePrint(const T
& value
, ::std::ostream
* os
) {
844 UniversalTersePrinter
<T
>::Print(value
, os
);
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.
851 template <typename T
>
852 void 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.
856 UniversalPrinter
<T1
>::Print(value
, os
);
859 typedef ::std::vector
<string
> Strings
;
861 // TuplePolicy<TupleT> must provide:
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.
868 template <typename TupleT
>
871 #if GTEST_HAS_TR1_TUPLE
872 template <typename TupleT
>
874 typedef TupleT Tuple
;
875 static const size_t tuple_size
= ::std::tr1::tuple_size
<Tuple
>::value
;
878 struct tuple_element
: ::std::tr1::tuple_element
<I
, Tuple
> {};
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
);
887 template <typename TupleT
>
888 const size_t TuplePolicy
<TupleT
>::tuple_size
;
889 #endif // GTEST_HAS_TR1_TUPLE
891 #if GTEST_HAS_STD_TUPLE_
892 template <typename
... Types
>
893 struct TuplePolicy
< ::std::tuple
<Types
...> > {
894 typedef ::std::tuple
<Types
...> Tuple
;
895 static const size_t tuple_size
= ::std::tuple_size
<Tuple
>::value
;
898 struct tuple_element
: ::std::tuple_element
<I
, Tuple
> {};
901 static const typename ::std::tuple_element
<I
, Tuple
>::type
& get(
902 const Tuple
& tuple
) {
903 return ::std::get
<I
>(tuple
);
906 template <typename
... Types
>
907 const size_t TuplePolicy
< ::std::tuple
<Types
...> >::tuple_size
;
908 #endif // GTEST_HAS_STD_TUPLE_
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>.
918 // The inductive case.
920 struct 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_()
927 GTEST_INTENTIONAL_CONST_COND_POP_()
931 typename TuplePolicy
<Tuple
>::template tuple_element
<N
- 1>::type
>
932 ::Print(TuplePolicy
<Tuple
>::template get
<N
- 1>(t
), os
);
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());
948 struct TuplePrefixPrinter
<0> {
949 template <typename Tuple
>
950 static void PrintPrefixTo(const Tuple
&, ::std::ostream
*) {}
952 template <typename Tuple
>
953 static void TersePrintPrefixToStrings(const Tuple
&, Strings
*) {}
956 // Helper function for printing a tuple.
957 // Tuple must be either std::tr1::tuple or std::tuple type.
958 template <typename Tuple
>
959 void PrintTupleTo(const Tuple
& t
, ::std::ostream
* os
) {
961 TuplePrefixPrinter
<TuplePolicy
<Tuple
>::tuple_size
>::PrintPrefixTo(t
, os
);
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".
968 template <typename Tuple
>
969 Strings
UniversalTersePrintTupleFieldsToStrings(const Tuple
& value
) {
971 TuplePrefixPrinter
<TuplePolicy
<Tuple
>::tuple_size
>::
972 TersePrintPrefixToStrings(value
, &result
);
975 #endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
977 } // namespace internal
979 template <typename T
>
980 ::std::string
PrintToString(const T
& value
) {
981 ::std::stringstream ss
;
982 internal::UniversalTersePrinter
<T
>::Print(value
, &ss
);
986 } // namespace testing
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"
993 #endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_