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 (at) 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 110 namespace 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! 114 namespace internal2 { 115 116 // Prints the given number of bytes in the given object to the given 117 // ostream. 118 GTEST_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(). 124 enum 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. 135 template <typename T, TypeKind kTypeKind> 136 class 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. 148 const size_t kProtobufOneLinerMaxLength = 50; 149 150 template <typename T> 151 class 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 162 template <typename T> 163 class 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. 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); 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. 217 namespace 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. 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 << 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 254 namespace testing { 255 namespace 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. 272 template <typename ToPrint, typename OtherOperand> 273 class FormatForComparison { 274 public: 275 static ::std::string Format(const ToPrint& value) { 276 return ::testing::PrintToString(value); 277 } 278 }; 279 280 // Array. 281 template <typename ToPrint, size_t N, typename OtherOperand> 282 class 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 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); 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 320 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string); 321 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string); 322 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); 326 #endif 327 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); 331 #endif 332 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); 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. 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); 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. 361 template <typename T> 362 class UniversalPrinter; 363 364 template <typename T> 365 void 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. 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. 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.) 403 template <typename T> 404 void 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. 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); 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). 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. 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. 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); 492 } 493 494 // Overloads for other simple built-in types. 495 inline 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. 506 GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); 507 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); 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. 516 inline void PrintTo(const signed char* s, ::std::ostream* os) { 517 PrintTo(ImplicitCast_<const void*>(s), os); 518 } 519 inline void PrintTo(signed char* s, ::std::ostream* os) { 520 PrintTo(ImplicitCast_<const void*>(s), os); 521 } 522 inline void PrintTo(const unsigned char* s, ::std::ostream* os) { 523 PrintTo(ImplicitCast_<const void*>(s), os); 524 } 525 inline 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 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); 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. 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++) { 551 *os << ", "; 552 UniversalPrint(a[i], os); 553 } 554 } 555 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); 561 } 562 #endif // GTEST_HAS_GLOBAL_STRING 563 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); 567 } 568 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); 574 } 575 #endif // GTEST_HAS_GLOBAL_WSTRING 576 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); 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. 587 template <typename T> 588 void 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 600 inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { 601 PrintTupleTo(t, os); 602 } 603 604 template <typename T1> 605 void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) { 606 PrintTupleTo(t, os); 607 } 608 609 template <typename T1, typename T2> 610 void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) { 611 PrintTupleTo(t, os); 612 } 613 614 template <typename T1, typename T2, typename T3> 615 void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) { 616 PrintTupleTo(t, os); 617 } 618 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) { 621 PrintTupleTo(t, os); 622 } 623 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) { 627 PrintTupleTo(t, os); 628 } 629 630 template <typename T1, typename T2, typename T3, typename T4, typename T5, 631 typename T6> 632 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t, 633 ::std::ostream* os) { 634 PrintTupleTo(t, os); 635 } 636 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) { 641 PrintTupleTo(t, os); 642 } 643 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) { 648 PrintTupleTo(t, os); 649 } 650 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) { 655 PrintTupleTo(t, os); 656 } 657 658 template <typename T1, typename T2, typename T3, typename T4, typename T5, 659 typename T6, typename T7, typename T8, typename T9, typename T10> 660 void 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_ 668 template <typename... Types> 669 void 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. 675 template <typename T1, typename T2> 676 void 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. 688 template <typename T> 689 class 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'. 715 template <typename T> 716 void 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 (at) 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. 738 GTEST_API_ void UniversalPrintArray( 739 const char* begin, size_t len, ::std::ostream* os); 740 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); 744 745 // Implements printing an array type T[N]. 746 template <typename T, size_t N> 747 class 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&. 757 template <typename T> 758 class 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 780 template <typename T> 781 class UniversalTersePrinter { 782 public: 783 static void Print(const T& value, ::std::ostream* os) { 784 UniversalPrint(value, os); 785 } 786 }; 787 template <typename T> 788 class UniversalTersePrinter<T&> { 789 public: 790 static void Print(const T& value, ::std::ostream* os) { 791 UniversalPrint(value, os); 792 } 793 }; 794 template <typename T, size_t N> 795 class 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 }; 801 template <> 802 class 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 }; 812 template <> 813 class 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 821 template <> 822 class 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 834 template <> 835 class 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 842 template <typename T> 843 void 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. 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. 855 typedef T T1; 856 UniversalPrinter<T1>::Print(value, os); 857 } 858 859 typedef ::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. 868 template <typename TupleT> 869 struct TuplePolicy; 870 871 #if GTEST_HAS_TR1_TUPLE 872 template <typename TupleT> 873 struct 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 }; 887 template <typename TupleT> 888 const size_t TuplePolicy<TupleT>::tuple_size; 889 #endif // GTEST_HAS_TR1_TUPLE 890 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; 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 }; 906 template <typename... Types> 907 const 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. 919 template <size_t N> 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_() 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. 947 template <> 948 struct 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. 958 template <typename Tuple> 959 void 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". 968 template <typename Tuple> 969 Strings 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 979 template <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