15891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Copyright 2007, Google Inc. 25891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// All rights reserved. 35891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 45891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Redistribution and use in source and binary forms, with or without 55891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// modification, are permitted provided that the following conditions are 65891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// met: 75891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 85891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// * Redistributions of source code must retain the above copyright 95891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// notice, this list of conditions and the following disclaimer. 105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// * Redistributions in binary form must reproduce the above 115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// copyright notice, this list of conditions and the following disclaimer 125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// in the documentation and/or other materials provided with the 135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// distribution. 145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// * Neither the name of Google Inc. nor the names of its 155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// contributors may be used to endorse or promote products derived from 165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// this software without specific prior written permission. 175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 185891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 195891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 205891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 215891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 225891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 235891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 245891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 255891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 265891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 275891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Author: wan@google.com (Zhanyong Wan) 315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Google Test - The Google C++ Testing Framework 335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// This file implements a universal value printer that can print a 355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// value of any type T: 365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); 385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// A user can teach this function how to print a class type T by 405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// defining either operator<<() or PrintTo() in the namespace that 415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// defines T. More specifically, the FIRST defined function in the 425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// following list will be used (assuming T is defined in namespace 435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// foo): 445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 1. foo::PrintTo(const T&, ostream*) 465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 2. operator<<(ostream&, const T&) defined in either foo or the 475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// global namespace. 485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// If none of the above is defined, it will print the debug string of 505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// the value if it is a protocol buffer, or print the raw bytes in the 515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// value otherwise. 525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// To aid debugging: when T is a reference type, the address of the 545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// value is also printed; when T is a (const) char pointer, both the 555891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// pointer value and the NUL-terminated string it points to are 565891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// printed. 575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// We also provide some convenient wrappers: 595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // Prints a value to a string. For a (const or not) char 615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // pointer, the NUL-terminated string (but not the pointer) is 625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // printed. 635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// std::string ::testing::PrintToString(const T& value); 645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // Prints a value tersely: for a reference type, the referenced 665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // value (but not the address) is printed; for a (const or not) char 675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // pointer, the NUL-terminated string (but not the pointer) is 685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // printed. 695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// void ::testing::internal::UniversalTersePrint(const T& value, ostream*); 705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // Prints value using the type inferred by the compiler. The difference 725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // from UniversalTersePrint() is that this function prints both the 735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // pointer and the NUL-terminated string for a (const or not) char pointer. 745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// void ::testing::internal::UniversalPrint(const T& value, ostream*); 755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // Prints the fields of a tuple tersely to a string vector, one 775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // element for each field. Tuple support must be enabled in 785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// // gtest-port.h. 795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// std::vector<string> UniversalTersePrintTupleFieldsToStrings( 805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// const Tuple& value); 815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Known limitation: 835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// The print primitives print the elements of an STL-style container 855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// using the compiler-inferred type of *iter where iter is a 865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// const_iterator of the container. When const_iterator is an input 875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// iterator but not a forward iterator, this inferred type may not 885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// match value_type, and the print output may be incorrect. In 895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// practice, this is rarely a problem as for most containers 905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// const_iterator is a forward iterator. We'll fix this if there's an 915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// actual need for it. Note that this fix cannot rely on value_type 925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// being defined as many user-defined container types don't have 935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// value_type. 945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#include <ostream> // NOLINT 995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#include <sstream> 1005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#include <string> 1015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#include <utility> 1025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#include <vector> 103731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "gtest/internal/gtest-port.h" 104731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "gtest/internal/gtest-internal.h" 1055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsennamespace testing { 1075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Definitions in the 'internal' and 'internal2' name spaces are 1095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// subject to change without notice. DO NOT USE THEM IN USER CODE! 1105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsennamespace internal2 { 1115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints the given number of bytes in the given object to the given 1135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// ostream. 1145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, 1155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen size_t count, 1165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os); 1175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 118731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// For selecting which printer to use when a given type has neither << 119731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// nor PrintTo(). 120731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickenum TypeKind { 121731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kProtobuf, // a protobuf type 122731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kConvertibleToInteger, // a type implicitly convertible to BiggestInt 123731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // (e.g. a named or unnamed enum type) 124dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen kOtherType // anything else 125731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick}; 126731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 127731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called 1285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// by the universal printer to print a value of type T when neither 129731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// operator<< nor PrintTo() is defined for T, where kTypeKind is the 130731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// "kind" of T as defined by enum TypeKind. 131731df977c0511bca2206b5f333555b1205ff1f43Iain Merricktemplate <typename T, TypeKind kTypeKind> 1325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenclass TypeWithoutFormatter { 1335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen public: 134731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // This default version is called when kTypeKind is kOtherType. 1355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void PrintValue(const T& value, ::std::ostream* os) { 1365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value), 1375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen sizeof(value), os); 1385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 1395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 1405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// We print a protobuf using its ShortDebugString() when the string 1425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// doesn't exceed this many characters; otherwise we print it using 1435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// DebugString() for better readability. 1445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenconst size_t kProtobufOneLinerMaxLength = 50; 1455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 147731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickclass TypeWithoutFormatter<T, kProtobuf> { 1485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen public: 1495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void PrintValue(const T& value, ::std::ostream* os) { 1505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const ::testing::internal::string short_str = value.ShortDebugString(); 1515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const ::testing::internal::string pretty_str = 1525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen short_str.length() <= kProtobufOneLinerMaxLength ? 1535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen short_str : ("\n" + value.DebugString()); 154731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick *os << ("<" + pretty_str + ">"); 155731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 156731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick}; 157731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 158731df977c0511bca2206b5f333555b1205ff1f43Iain Merricktemplate <typename T> 159731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickclass TypeWithoutFormatter<T, kConvertibleToInteger> { 160731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick public: 161731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Since T has no << operator or PrintTo() but can be implicitly 162731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // converted to BiggestInt, we print it as a BiggestInt. 163731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // 164731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Most likely T is an enum type (either named or unnamed), in which 165731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // case printing it as an integer is the desired behavior. In case 166731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // T is not an enum, printing it as an integer is the best we can do 167731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // given that it has no user-defined printer. 168731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick static void PrintValue(const T& value, ::std::ostream* os) { 169731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const internal::BiggestInt kBigInt = value; 170731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick *os << kBigInt; 1715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 1725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 1735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 1745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints the given value to the given ostream. If the value is a 175731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// protocol message, its debug string is printed; if it's an enum or 176731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// of a type implicitly convertible to BiggestInt, it's printed as an 177731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// integer; otherwise the bytes in the value are printed. This is 178731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// what UniversalPrinter<T>::Print() does when it knows nothing about 179731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// type T and T has neither << operator nor PrintTo(). 1805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 1815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// A user can override this behavior for a class type Foo by defining 1825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// a << operator in the namespace where Foo is defined. 1835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 1845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// We put this operator in namespace 'internal2' instead of 'internal' 1855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// to simplify the implementation, as much code in 'internal' needs to 1865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// use << in STL, which would conflict with our own << were it defined 1875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// in 'internal'. 1885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 1895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Note that this operator<< takes a generic std::basic_ostream<Char, 1905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// CharTraits> type instead of the more restricted std::ostream. If 1915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// we define it to take an std::ostream instead, we'll get an 1925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// "ambiguous overloads" compiler error when trying to print a type 1935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Foo that supports streaming to std::basic_ostream<Char, 1945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// CharTraits>, as the compiler cannot tell whether 1955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// operator<<(std::ostream&, const T&) or 1965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more 1975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// specific. 1985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename Char, typename CharTraits, typename T> 1995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen::std::basic_ostream<Char, CharTraits>& operator<<( 2005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::basic_ostream<Char, CharTraits>& os, const T& x) { 201731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TypeWithoutFormatter<T, 202731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick (internal::IsAProtocolMessage<T>::value ? kProtobuf : 203731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ? 204731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kConvertibleToInteger : kOtherType)>::PrintValue(x, &os); 2055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen return os; 2065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 2075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} // namespace internal2 2095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} // namespace testing 2105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up 2125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// magic needed for implementing UniversalPrinter won't work. 2135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsennamespace testing_internal { 2145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Used to print a value that is not an STL-style container when the 2165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// user doesn't define PrintTo() for it. 2175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 2185891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) { 2195891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // With the following statement, during unqualified name lookup, 2205891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // testing::internal2::operator<< appears as if it was declared in 2215891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // the nearest enclosing namespace that contains both 2225891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // ::testing_internal and ::testing::internal2, i.e. the global 2235891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // namespace. For more details, refer to the C++ Standard section 2245891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 7.3.4-1 [namespace.udir]. This allows us to fall back onto 2255891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // testing::internal2::operator<< in case T doesn't come with a << 2265891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // operator. 2275891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 2285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // We cannot write 'using ::testing::internal2::operator<<;', which 2295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // gcc 3.3 fails to compile due to a compiler bug. 2305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen using namespace ::testing::internal2; // NOLINT 2315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Assuming T is defined in namespace foo, in the next statement, 2335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // the compiler will consider all of: 2345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 2355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 1. foo::operator<< (thanks to Koenig look-up), 2365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 2. ::operator<< (as the current namespace is enclosed in ::), 2375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 3. testing::internal2::operator<< (thanks to the using statement above). 2385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 2395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // The operator<< whose type matches T best will be picked. 2405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 2415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // We deliberately allow #2 to be a candidate, as sometimes it's 2425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // impossible to define #1 (e.g. when foo is ::std, defining 2435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // anything in it is undefined behavior unless you are a compiler 2445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // vendor.). 2455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << value; 2465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 2475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} // namespace testing_internal 2495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsennamespace testing { 2515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsennamespace internal { 2525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given 2545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// value to the given ostream. The caller must ensure that 2555891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 'ostream_ptr' is not NULL, or the behavior is undefined. 2565891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 2575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// We define UniversalPrinter as a class template (as opposed to a 2585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// function template), as we need to partially specialize it for 2595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// reference types, which cannot be done with function templates. 2605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 2615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenclass UniversalPrinter; 2625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 2645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid UniversalPrint(const T& value, ::std::ostream* os); 2655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Used to print an STL-style container when the user doesn't define 2675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// a PrintTo() for it. 2685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename C> 2695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid DefaultPrintTo(IsContainer /* dummy */, 2705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen false_type /* is not a pointer */, 2715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const C& container, ::std::ostream* os) { 2725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const size_t kMaxCount = 32; // The maximum number of elements to print. 2735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << '{'; 2745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen size_t count = 0; 2755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen for (typename C::const_iterator it = container.begin(); 2765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen it != container.end(); ++it, ++count) { 2775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (count > 0) { 2785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ','; 2795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (count == kMaxCount) { // Enough has been printed. 2805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << " ..."; 2815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen break; 2825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 2835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 2845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ' '; 2855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // We cannot call PrintTo(*it, os) here as PrintTo() doesn't 2865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // handle *it being a native array. 2875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen internal::UniversalPrint(*it, os); 2885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 2895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (count > 0) { 2915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ' '; 2925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 2935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << '}'; 2945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 2955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 2965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Used to print a pointer that is neither a char pointer nor a member 2975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// pointer, when the user doesn't define PrintTo() for it. (A member 2985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// variable pointer or member function pointer doesn't really point to 2995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// a location in the address space. Their representation is 3005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// implementation-defined. Therefore they will be printed as raw 3015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// bytes.) 3025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 3035891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid DefaultPrintTo(IsNotContainer /* dummy */, 3045891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen true_type /* is a pointer */, 3055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen T* p, ::std::ostream* os) { 3065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (p == NULL) { 3075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "NULL"; 3085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } else { 309731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // C++ doesn't allow casting from a function pointer to any object 310731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // pointer. 311ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen // 312ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen // IsTrue() silences warnings: "Condition is always true", 313ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen // "unreachable code". 314ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) { 315731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // T is not a function type. We just call << to print p, 316731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // relying on ADL to pick up user-defined << for their pointer 317731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // types, if any. 318731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick *os << p; 319731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } else { 320731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // T is a function type, so '*os << p' doesn't do what we want 321731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // (it just prints p as bool). We want to print p as a const 322731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // void*. However, we cannot cast it to const void* directly, 323731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // even using reinterpret_cast, as earlier versions of gcc 324731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // (e.g. 3.4.5) cannot compile the cast when p is a function 325731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // pointer. Casting to UInt64 first solves the problem. 326731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick *os << reinterpret_cast<const void*>( 327731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick reinterpret_cast<internal::UInt64>(p)); 328731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 3295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 3305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 3315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Used to print a non-container, non-pointer value when the user 3335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// doesn't define PrintTo() for it. 3345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 3355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid DefaultPrintTo(IsNotContainer /* dummy */, 3365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen false_type /* is not a pointer */, 3375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const T& value, ::std::ostream* os) { 3385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::testing_internal::DefaultPrintNonContainerTo(value, os); 3395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 3405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints the given value using the << operator if it has one; 3425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// otherwise prints the bytes in it. This is what 3435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalPrinter<T>::Print() does when PrintTo() is not specialized 3445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// or overloaded for type T. 3455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// 3465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// A user can override this behavior for a class type Foo by defining 3475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// an overload of PrintTo() in the namespace where Foo is defined. We 3485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// give the user this option as sometimes defining a << operator for 3495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Foo is not desirable (e.g. the coding style may prevent doing it, 3505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// or there is already a << operator but it doesn't do what the user 3515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// wants). 3525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 3535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const T& value, ::std::ostream* os) { 3545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // DefaultPrintTo() is overloaded. The type of its first two 3555891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // arguments determine which version will be picked. If T is an 3565891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // STL-style container, the version for container will be called; if 3575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // T is a pointer, the pointer version will be called; otherwise the 3585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // generic version will be called. 3595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 3605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Note that we check for container types here, prior to we check 3615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // for protocol message types in our operator<<. The rationale is: 3625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 3635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // For protocol messages, we want to give people a chance to 3645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // override Google Mock's format by defining a PrintTo() or 3655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // operator<<. For STL containers, other formats can be 3665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // incompatible with Google Mock's format for the container 3675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // elements; therefore we check for container types here to ensure 3685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // that our format is used. 3695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 3705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // The second argument of DefaultPrintTo() is needed to bypass a bug 3715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // in Symbian's C++ compiler that prevents it from picking the right 3725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // overload between: 3735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 3745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // PrintTo(const T& x, ...); 3755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // PrintTo(T* x, ...); 3765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os); 3775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 3785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// The following list of PrintTo() overloads tells 3805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalPrinter<T>::Print() how to print standard types (built-in 3815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// types, strings, plain arrays, and pointers). 3825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for various char types. 384731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickGTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); 385731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickGTEST_API_ void PrintTo(signed char c, ::std::ostream* os); 3865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(char c, ::std::ostream* os) { 3875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // When printing a plain char, we always treat it as unsigned. This 3885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // way, the output won't be affected by whether the compiler thinks 3895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // char is signed or not. 3905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTo(static_cast<unsigned char>(c), os); 3915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 3925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for other simple built-in types. 3945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(bool x, ::std::ostream* os) { 3955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << (x ? "true" : "false"); 3965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 3975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 3985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overload for wchar_t type. 3995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints a wchar_t as a symbol if it is printable or as its internal 4005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// code otherwise and also as its decimal code (except for L'\0'). 4015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// The L'\0' char is printed as "L'\\0'". The decimal code is printed 4025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// as signed integer when wchar_t is implemented by the compiler 4035891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// as a signed type and is printed as an unsigned integer when wchar_t 4045891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// is implemented as an unsigned type. 4055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); 4065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for C strings. 4085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintTo(const char* s, ::std::ostream* os); 4095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(char* s, ::std::ostream* os) { 410dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const char*>(s), os); 4115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 413731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// signed/unsigned char is often used for representing binary data, so 414731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// we print pointers to it as void* to be safe. 415731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickinline void PrintTo(const signed char* s, ::std::ostream* os) { 416dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const void*>(s), os); 417731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 418731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickinline void PrintTo(signed char* s, ::std::ostream* os) { 419dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const void*>(s), os); 420731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 421731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickinline void PrintTo(const unsigned char* s, ::std::ostream* os) { 422dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const void*>(s), os); 423731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 424731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickinline void PrintTo(unsigned char* s, ::std::ostream* os) { 425dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const void*>(s), os); 426731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 427731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 4285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// MSVC can be configured to define wchar_t as a typedef of unsigned 4295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native 4305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// type. When wchar_t is a typedef, defining an overload for const 4315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// wchar_t* would cause unsigned short* be printed as a wide string, 4325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// possibly causing invalid memory accesses. 4335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) 4345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for wide C strings 4355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); 4365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(wchar_t* s, ::std::ostream* os) { 437dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintTo(ImplicitCast_<const wchar_t*>(s), os); 4385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif 4405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overload for C arrays. Multi-dimensional arrays are printed 4425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// properly. 4435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints the given number of elements in an array, without printing 4455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// the curly braces. 4465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 4475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { 4485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrint(a[0], os); 4495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen for (size_t i = 1; i != count; i++) { 4505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ", "; 4515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrint(a[i], os); 4525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 4535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4555891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for ::string and ::std::string. 4565891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if GTEST_HAS_GLOBAL_STRING 4575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os); 4585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(const ::string& s, ::std::ostream* os) { 4595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintStringTo(s, os); 4605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_HAS_GLOBAL_STRING 4625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); 4645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(const ::std::string& s, ::std::ostream* os) { 4655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintStringTo(s, os); 4665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloads for ::wstring and ::std::wstring. 4695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if GTEST_HAS_GLOBAL_WSTRING 4705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os); 4715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(const ::wstring& s, ::std::ostream* os) { 4725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintWideStringTo(s, os); 4735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_HAS_GLOBAL_WSTRING 4755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if GTEST_HAS_STD_WSTRING 4775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); 4785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { 4795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintWideStringTo(s, os); 4805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 4815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_HAS_STD_WSTRING 4825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if GTEST_HAS_TR1_TUPLE 4845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overload for ::std::tr1::tuple. Needed for printing function arguments, 4855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// which are packed as tuples. 4865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Helper function for printing a tuple. T must be instantiated with 4885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// a tuple type. 4895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 4905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTupleTo(const T& t, ::std::ostream* os); 4915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overloaded PrintTo() for tuples of various arities. We support 4935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// tuples of up-to 10 fields. The following implementation works 4945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// regardless of whether tr1::tuple is implemented using the 4955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// non-standard variadic template feature or not. 4965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 4975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { 4985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 4995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1> 5025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) { 5035891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5045891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2> 5075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) { 5085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3> 5125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) { 5135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4> 5175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) { 5185891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5195891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5205891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5215891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5> 5225891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t, 5235891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5245891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5255891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5265891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5275891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 5285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen typename T6> 5295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t, 5305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 5355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen typename T6, typename T7> 5365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t, 5375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 5425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen typename T6, typename T7, typename T8> 5435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t, 5445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 5495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen typename T6, typename T7, typename T8, typename T9> 5505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t, 5515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5555891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 5565891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen typename T6, typename T7, typename T8, typename T9, typename T10> 5575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo( 5585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t, 5595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os) { 5605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTupleTo(t, os); 5615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_HAS_TR1_TUPLE 5635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Overload for std::pair. 5655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T1, typename T2> 5665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) { 5675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << '('; 5685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // We cannot use UniversalPrint(value.first, os) here, as T1 may be 5695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // a reference type. The same for printing value.second. 5705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrinter<T1>::Print(value.first, os); 5715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ", "; 5725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrinter<T2>::Print(value.second, os); 5735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ')'; 5745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 5755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Implements printing a non-reference type T by letting the compiler 5775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// pick the right overload of PrintTo() for T. 5785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 5795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenclass UniversalPrinter { 5805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen public: 5815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // MSVC warns about adding const to a function type, so we want to 5825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // disable the warning. 5835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#ifdef _MSC_VER 584ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(push) // Saves the current warning state. 585ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(disable:4180) // Temporarily disables warning 4180. 5865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // _MSC_VER 5875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 5885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Note: we deliberately don't call this PrintTo(), as that name 5895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // conflicts with ::testing::internal::PrintTo in the body of the 5905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // function. 5915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void Print(const T& value, ::std::ostream* os) { 5925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // By default, ::testing::internal::PrintTo() is used for printing 5935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // the value. 5945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // 5955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Thanks to Koenig look-up, if T is a class and has its own 5965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // PrintTo() function defined in its namespace, that function will 5975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // be visible here. Since it is more specific than the generic ones 5985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // in ::testing::internal, it will be picked by the compiler in the 5995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // following statement - exactly what we want. 6005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintTo(value, os); 6015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6035891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#ifdef _MSC_VER 604ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(pop) // Restores the warning state. 6055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // _MSC_VER 6065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 6075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalPrintArray(begin, len, os) prints an array of 'len' 6095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// elements, starting at address 'begin'. 6105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 6115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { 6125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (len == 0) { 6135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "{}"; 6145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } else { 6155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "{ "; 6165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const size_t kThreshold = 18; 6175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen const size_t kChunkSize = 8; 6185891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // If the array has more than kThreshold elements, we'll have to 6195891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // omit some details by printing only the first and the last 6205891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // kChunkSize elements. 6215891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // TODO(wan@google.com): let the user control the threshold using a flag. 6225891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (len <= kThreshold) { 6235891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintRawArrayTo(begin, len, os); 6245891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } else { 6255891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintRawArrayTo(begin, kChunkSize, os); 6265891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ", ..., "; 6275891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); 6285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << " }"; 6305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 6325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// This overload prints a (const) char array compactly. 6335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenGTEST_API_ void UniversalPrintArray(const char* begin, 6345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen size_t len, 6355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::ostream* os); 6365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Implements printing an array type T[N]. 6385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T, size_t N> 6395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenclass UniversalPrinter<T[N]> { 6405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen public: 6415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Prints the given array, omitting some elements when there are too 6425891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // many. 6435891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void Print(const T (&a)[N], ::std::ostream* os) { 6445891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrintArray(a, N, os); 6455891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6465891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 6475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6485891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Implements printing a reference type T&. 6495891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 6505891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenclass UniversalPrinter<T&> { 6515891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen public: 6525891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // MSVC warns about adding const to a function type, so we want to 6535891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // disable the warning. 6545891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#ifdef _MSC_VER 655ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(push) // Saves the current warning state. 656ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(disable:4180) // Temporarily disables warning 4180. 6575891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // _MSC_VER 6585891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6595891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void Print(const T& value, ::std::ostream* os) { 6605891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Prints the address of the value. We use reinterpret_cast here 6615891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // as static_cast doesn't compile when T is a function type. 6625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "@" << reinterpret_cast<const void*>(&value) << " "; 6635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Then prints the value itself. 6655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrint(value, os); 6665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#ifdef _MSC_VER 669ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(pop) // Restores the warning state. 6705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // _MSC_VER 6715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 6725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints a value tersely: for a reference type, the referenced value 6745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// (but not the address) is printed; for a (const) char pointer, the 6755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// NUL-terminated string (but not the pointer) is printed. 6765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 6775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid UniversalTersePrint(const T& value, ::std::ostream* os) { 6785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrint(value, os); 6795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 6805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void UniversalTersePrint(const char* str, ::std::ostream* os) { 6815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen if (str == NULL) { 6825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "NULL"; 6835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } else { 6845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrint(string(str), os); 6855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 6865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 6875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monseninline void UniversalTersePrint(char* str, ::std::ostream* os) { 6885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalTersePrint(static_cast<const char*>(str), os); 6895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 6905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 6915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints a value using the type inferred by the compiler. The 6925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// difference between this and UniversalTersePrint() is that for a 6935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// (const) char pointer, this prints both the pointer and the 6945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// NUL-terminated string. 6955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 6965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid UniversalPrint(const T& value, ::std::ostream* os) { 6975891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrinter<T>::Print(value, os); 6985891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 6995891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7005891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#if GTEST_HAS_TR1_TUPLE 7015891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentypedef ::std::vector<string> Strings; 7025891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7035891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// This helper template allows PrintTo() for tuples and 7045891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalTersePrintTupleFieldsToStrings() to be defined by 7055891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// induction on the number of tuple fields. The idea is that 7065891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N 7075891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// fields in tuple t, and can be defined in terms of 7085891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// TuplePrefixPrinter<N - 1>. 7095891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7105891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// The inductive case. 7115891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <size_t N> 7125891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenstruct TuplePrefixPrinter { 7135891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Prints the first N fields of a tuple. 7145891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen template <typename Tuple> 7155891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { 7165891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os); 7175891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ", "; 7185891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type> 7195891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::Print(::std::tr1::get<N - 1>(t), os); 7205891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 7215891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7225891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // Tersely prints the first N fields of a tuple to a string vector, 7235891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen // one element for each field. 7245891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen template <typename Tuple> 7255891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { 7265891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings); 7275891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::stringstream ss; 7285891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss); 7295891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen strings->push_back(ss.str()); 7305891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen } 7315891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 7325891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7335891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Base cases. 7345891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <> 7355891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenstruct TuplePrefixPrinter<0> { 7365891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen template <typename Tuple> 7375891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void PrintPrefixTo(const Tuple&, ::std::ostream*) {} 7385891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7395891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen template <typename Tuple> 7405891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen static void TersePrintPrefixToStrings(const Tuple&, Strings*) {} 7415891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen}; 742ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// We have to specialize the entire TuplePrefixPrinter<> class 743ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// template here, even though the definition of 744ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// TersePrintPrefixToStrings() is the same as the generic version, as 745ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't 746ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// support specializing a method template of a class template. 7475891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <> 748ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsenstruct TuplePrefixPrinter<1> { 749ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen template <typename Tuple> 750ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { 751ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>:: 752ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen Print(::std::tr1::get<0>(t), os); 753ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen } 754ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 755ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen template <typename Tuple> 756ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { 757ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen ::std::stringstream ss; 758ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen UniversalTersePrint(::std::tr1::get<0>(t), &ss); 759ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen strings->push_back(ss.str()); 760ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen } 761ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen}; 7625891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7635891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Helper function for printing a tuple. T must be instantiated with 7645891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// a tuple type. 7655891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 7665891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsenvoid PrintTupleTo(const T& t, ::std::ostream* os) { 7675891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << "("; 7685891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>:: 7695891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen PrintPrefixTo(t, os); 7705891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen *os << ")"; 7715891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 7725891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7735891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// Prints the fields of a tuple tersely to a string vector, one 7745891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// element for each field. See the comment before 7755891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen// UniversalTersePrint() for how we define "tersely". 7765891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename Tuple> 7775891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian MonsenStrings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { 7785891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen Strings result; 7795891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>:: 7805891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen TersePrintPrefixToStrings(value, &result); 7815891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen return result; 7825891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 7835891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_HAS_TR1_TUPLE 7845891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7855891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} // namespace internal 7865891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7875891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsentemplate <typename T> 7885891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen::std::string PrintToString(const T& value) { 7895891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen ::std::stringstream ss; 7905891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen internal::UniversalTersePrint(value, &ss); 7915891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen return ss.str(); 7925891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} 7935891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7945891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen} // namespace testing 7955891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen 7965891636149dae2ecc0fadb3aec0cbc8ca0fa045dKristian Monsen#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 797