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