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