Qucs-core  0.0.19
gtest-printers.h
Go to the documentation of this file.
00001 // Copyright 2007, Google Inc.
00002 // All rights reserved.
00003 //
00004 // Redistribution and use in source and binary forms, with or without
00005 // modification, are permitted provided that the following conditions are
00006 // met:
00007 //
00008 //     * Redistributions of source code must retain the above copyright
00009 // notice, this list of conditions and the following disclaimer.
00010 //     * Redistributions in binary form must reproduce the above
00011 // copyright notice, this list of conditions and the following disclaimer
00012 // in the documentation and/or other materials provided with the
00013 // distribution.
00014 //     * Neither the name of Google Inc. nor the names of its
00015 // contributors may be used to endorse or promote products derived from
00016 // this software without specific prior written permission.
00017 //
00018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00019 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00020 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00021 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00022 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00023 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00024 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00025 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00026 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00027 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00028 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 //
00030 // Author: wan@google.com (Zhanyong Wan)
00031 
00032 // Google Test - The Google C++ Testing Framework
00033 //
00034 // This file implements a universal value printer that can print a
00035 // value of any type T:
00036 //
00037 //   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
00038 //
00039 // A user can teach this function how to print a class type T by
00040 // defining either operator<<() or PrintTo() in the namespace that
00041 // defines T.  More specifically, the FIRST defined function in the
00042 // following list will be used (assuming T is defined in namespace
00043 // foo):
00044 //
00045 //   1. foo::PrintTo(const T&, ostream*)
00046 //   2. operator<<(ostream&, const T&) defined in either foo or the
00047 //      global namespace.
00048 //
00049 // If none of the above is defined, it will print the debug string of
00050 // the value if it is a protocol buffer, or print the raw bytes in the
00051 // value otherwise.
00052 //
00053 // To aid debugging: when T is a reference type, the address of the
00054 // value is also printed; when T is a (const) char pointer, both the
00055 // pointer value and the NUL-terminated string it points to are
00056 // printed.
00057 //
00058 // We also provide some convenient wrappers:
00059 //
00060 //   // Prints a value to a string.  For a (const or not) char
00061 //   // pointer, the NUL-terminated string (but not the pointer) is
00062 //   // printed.
00063 //   std::string ::testing::PrintToString(const T& value);
00064 //
00065 //   // Prints a value tersely: for a reference type, the referenced
00066 //   // value (but not the address) is printed; for a (const or not) char
00067 //   // pointer, the NUL-terminated string (but not the pointer) is
00068 //   // printed.
00069 //   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
00070 //
00071 //   // Prints value using the type inferred by the compiler.  The difference
00072 //   // from UniversalTersePrint() is that this function prints both the
00073 //   // pointer and the NUL-terminated string for a (const or not) char pointer.
00074 //   void ::testing::internal::UniversalPrint(const T& value, ostream*);
00075 //
00076 //   // Prints the fields of a tuple tersely to a string vector, one
00077 //   // element for each field. Tuple support must be enabled in
00078 //   // gtest-port.h.
00079 //   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
00080 //       const Tuple& value);
00081 //
00082 // Known limitation:
00083 //
00084 // The print primitives print the elements of an STL-style container
00085 // using the compiler-inferred type of *iter where iter is a
00086 // const_iterator of the container.  When const_iterator is an input
00087 // iterator but not a forward iterator, this inferred type may not
00088 // match value_type, and the print output may be incorrect.  In
00089 // practice, this is rarely a problem as for most containers
00090 // const_iterator is a forward iterator.  We'll fix this if there's an
00091 // actual need for it.  Note that this fix cannot rely on value_type
00092 // being defined as many user-defined container types don't have
00093 // value_type.
00094 
00095 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
00096 #define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
00097 
00098 #include <ostream>  // NOLINT
00099 #include <sstream>
00100 #include <string>
00101 #include <utility>
00102 #include <vector>
00103 #include "gtest/internal/gtest-port.h"
00104 #include "gtest/internal/gtest-internal.h"
00105 
00106 namespace testing {
00107 
00108 // Definitions in the 'internal' and 'internal2' name spaces are
00109 // subject to change without notice.  DO NOT USE THEM IN USER CODE!
00110 namespace internal2 {
00111 
00112 // Prints the given number of bytes in the given object to the given
00113 // ostream.
00114 GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
00115                                      size_t count,
00116                                      ::std::ostream* os);
00117 
00118 // For selecting which printer to use when a given type has neither <<
00119 // nor PrintTo().
00120 enum TypeKind {
00121   kProtobuf,              // a protobuf type
00122   kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
00123                           // (e.g. a named or unnamed enum type)
00124   kOtherType              // anything else
00125 };
00126 
00127 // TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
00128 // by the universal printer to print a value of type T when neither
00129 // operator<< nor PrintTo() is defined for T, where kTypeKind is the
00130 // "kind" of T as defined by enum TypeKind.
00131 template <typename T, TypeKind kTypeKind>
00132 class TypeWithoutFormatter {
00133  public:
00134   // This default version is called when kTypeKind is kOtherType.
00135   static void PrintValue(const T& value, ::std::ostream* os) {
00136     PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
00137                          sizeof(value), os);
00138   }
00139 };
00140 
00141 // We print a protobuf using its ShortDebugString() when the string
00142 // doesn't exceed this many characters; otherwise we print it using
00143 // DebugString() for better readability.
00144 const size_t kProtobufOneLinerMaxLength = 50;
00145 
00146 template <typename T>
00147 class TypeWithoutFormatter<T, kProtobuf> {
00148  public:
00149   static void PrintValue(const T& value, ::std::ostream* os) {
00150     const ::testing::internal::string short_str = value.ShortDebugString();
00151     const ::testing::internal::string pretty_str =
00152         short_str.length() <= kProtobufOneLinerMaxLength ?
00153         short_str : ("\n" + value.DebugString());
00154     *os << ("<" + pretty_str + ">");
00155   }
00156 };
00157 
00158 template <typename T>
00159 class TypeWithoutFormatter<T, kConvertibleToInteger> {
00160  public:
00161   // Since T has no << operator or PrintTo() but can be implicitly
00162   // converted to BiggestInt, we print it as a BiggestInt.
00163   //
00164   // Most likely T is an enum type (either named or unnamed), in which
00165   // case printing it as an integer is the desired behavior.  In case
00166   // T is not an enum, printing it as an integer is the best we can do
00167   // given that it has no user-defined printer.
00168   static void PrintValue(const T& value, ::std::ostream* os) {
00169     const internal::BiggestInt kBigInt = value;
00170     *os << kBigInt;
00171   }
00172 };
00173 
00174 // Prints the given value to the given ostream.  If the value is a
00175 // protocol message, its debug string is printed; if it's an enum or
00176 // of a type implicitly convertible to BiggestInt, it's printed as an
00177 // integer; otherwise the bytes in the value are printed.  This is
00178 // what UniversalPrinter<T>::Print() does when it knows nothing about
00179 // type T and T has neither << operator nor PrintTo().
00180 //
00181 // A user can override this behavior for a class type Foo by defining
00182 // a << operator in the namespace where Foo is defined.
00183 //
00184 // We put this operator in namespace 'internal2' instead of 'internal'
00185 // to simplify the implementation, as much code in 'internal' needs to
00186 // use << in STL, which would conflict with our own << were it defined
00187 // in 'internal'.
00188 //
00189 // Note that this operator<< takes a generic std::basic_ostream<Char,
00190 // CharTraits> type instead of the more restricted std::ostream.  If
00191 // we define it to take an std::ostream instead, we'll get an
00192 // "ambiguous overloads" compiler error when trying to print a type
00193 // Foo that supports streaming to std::basic_ostream<Char,
00194 // CharTraits>, as the compiler cannot tell whether
00195 // operator<<(std::ostream&, const T&) or
00196 // operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
00197 // specific.
00198 template <typename Char, typename CharTraits, typename T>
00199 ::std::basic_ostream<Char, CharTraits>& operator<<(
00200     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
00201   TypeWithoutFormatter<T,
00202       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
00203        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
00204        kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
00205   return os;
00206 }
00207 
00208 }  // namespace internal2
00209 }  // namespace testing
00210 
00211 // This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
00212 // magic needed for implementing UniversalPrinter won't work.
00213 namespace testing_internal {
00214 
00215 // Used to print a value that is not an STL-style container when the
00216 // user doesn't define PrintTo() for it.
00217 template <typename T>
00218 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
00219   // With the following statement, during unqualified name lookup,
00220   // testing::internal2::operator<< appears as if it was declared in
00221   // the nearest enclosing namespace that contains both
00222   // ::testing_internal and ::testing::internal2, i.e. the global
00223   // namespace.  For more details, refer to the C++ Standard section
00224   // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
00225   // testing::internal2::operator<< in case T doesn't come with a <<
00226   // operator.
00227   //
00228   // We cannot write 'using ::testing::internal2::operator<<;', which
00229   // gcc 3.3 fails to compile due to a compiler bug.
00230   using namespace ::testing::internal2;  // NOLINT
00231 
00232   // Assuming T is defined in namespace foo, in the next statement,
00233   // the compiler will consider all of:
00234   //
00235   //   1. foo::operator<< (thanks to Koenig look-up),
00236   //   2. ::operator<< (as the current namespace is enclosed in ::),
00237   //   3. testing::internal2::operator<< (thanks to the using statement above).
00238   //
00239   // The operator<< whose type matches T best will be picked.
00240   //
00241   // We deliberately allow #2 to be a candidate, as sometimes it's
00242   // impossible to define #1 (e.g. when foo is ::std, defining
00243   // anything in it is undefined behavior unless you are a compiler
00244   // vendor.).
00245   *os << value;
00246 }
00247 
00248 }  // namespace testing_internal
00249 
00250 namespace testing {
00251 namespace internal {
00252 
00253 // UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
00254 // value to the given ostream.  The caller must ensure that
00255 // 'ostream_ptr' is not NULL, or the behavior is undefined.
00256 //
00257 // We define UniversalPrinter as a class template (as opposed to a
00258 // function template), as we need to partially specialize it for
00259 // reference types, which cannot be done with function templates.
00260 template <typename T>
00261 class UniversalPrinter;
00262 
00263 template <typename T>
00264 void UniversalPrint(const T& value, ::std::ostream* os);
00265 
00266 // Used to print an STL-style container when the user doesn't define
00267 // a PrintTo() for it.
00268 template <typename C>
00269 void DefaultPrintTo(IsContainer /* dummy */,
00270                     false_type /* is not a pointer */,
00271                     const C& container, ::std::ostream* os) {
00272   const size_t kMaxCount = 32;  // The maximum number of elements to print.
00273   *os << '{';
00274   size_t count = 0;
00275   for (typename C::const_iterator it = container.begin();
00276        it != container.end(); ++it, ++count) {
00277     if (count > 0) {
00278       *os << ',';
00279       if (count == kMaxCount) {  // Enough has been printed.
00280         *os << " ...";
00281         break;
00282       }
00283     }
00284     *os << ' ';
00285     // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
00286     // handle *it being a native array.
00287     internal::UniversalPrint(*it, os);
00288   }
00289 
00290   if (count > 0) {
00291     *os << ' ';
00292   }
00293   *os << '}';
00294 }
00295 
00296 // Used to print a pointer that is neither a char pointer nor a member
00297 // pointer, when the user doesn't define PrintTo() for it.  (A member
00298 // variable pointer or member function pointer doesn't really point to
00299 // a location in the address space.  Their representation is
00300 // implementation-defined.  Therefore they will be printed as raw
00301 // bytes.)
00302 template <typename T>
00303 void DefaultPrintTo(IsNotContainer /* dummy */,
00304                     true_type /* is a pointer */,
00305                     T* p, ::std::ostream* os) {
00306   if (p == NULL) {
00307     *os << "NULL";
00308   } else {
00309     // C++ doesn't allow casting from a function pointer to any object
00310     // pointer.
00311     //
00312     // IsTrue() silences warnings: "Condition is always true",
00313     // "unreachable code".
00314     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
00315       // T is not a function type.  We just call << to print p,
00316       // relying on ADL to pick up user-defined << for their pointer
00317       // types, if any.
00318       *os << p;
00319     } else {
00320       // T is a function type, so '*os << p' doesn't do what we want
00321       // (it just prints p as bool).  We want to print p as a const
00322       // void*.  However, we cannot cast it to const void* directly,
00323       // even using reinterpret_cast, as earlier versions of gcc
00324       // (e.g. 3.4.5) cannot compile the cast when p is a function
00325       // pointer.  Casting to UInt64 first solves the problem.
00326       *os << reinterpret_cast<const void*>(
00327           reinterpret_cast<internal::UInt64>(p));
00328     }
00329   }
00330 }
00331 
00332 // Used to print a non-container, non-pointer value when the user
00333 // doesn't define PrintTo() for it.
00334 template <typename T>
00335 void DefaultPrintTo(IsNotContainer /* dummy */,
00336                     false_type /* is not a pointer */,
00337                     const T& value, ::std::ostream* os) {
00338   ::testing_internal::DefaultPrintNonContainerTo(value, os);
00339 }
00340 
00341 // Prints the given value using the << operator if it has one;
00342 // otherwise prints the bytes in it.  This is what
00343 // UniversalPrinter<T>::Print() does when PrintTo() is not specialized
00344 // or overloaded for type T.
00345 //
00346 // A user can override this behavior for a class type Foo by defining
00347 // an overload of PrintTo() in the namespace where Foo is defined.  We
00348 // give the user this option as sometimes defining a << operator for
00349 // Foo is not desirable (e.g. the coding style may prevent doing it,
00350 // or there is already a << operator but it doesn't do what the user
00351 // wants).
00352 template <typename T>
00353 void PrintTo(const T& value, ::std::ostream* os) {
00354   // DefaultPrintTo() is overloaded.  The type of its first two
00355   // arguments determine which version will be picked.  If T is an
00356   // STL-style container, the version for container will be called; if
00357   // T is a pointer, the pointer version will be called; otherwise the
00358   // generic version will be called.
00359   //
00360   // Note that we check for container types here, prior to we check
00361   // for protocol message types in our operator<<.  The rationale is:
00362   //
00363   // For protocol messages, we want to give people a chance to
00364   // override Google Mock's format by defining a PrintTo() or
00365   // operator<<.  For STL containers, other formats can be
00366   // incompatible with Google Mock's format for the container
00367   // elements; therefore we check for container types here to ensure
00368   // that our format is used.
00369   //
00370   // The second argument of DefaultPrintTo() is needed to bypass a bug
00371   // in Symbian's C++ compiler that prevents it from picking the right
00372   // overload between:
00373   //
00374   //   PrintTo(const T& x, ...);
00375   //   PrintTo(T* x, ...);
00376   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
00377 }
00378 
00379 // The following list of PrintTo() overloads tells
00380 // UniversalPrinter<T>::Print() how to print standard types (built-in
00381 // types, strings, plain arrays, and pointers).
00382 
00383 // Overloads for various char types.
00384 GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
00385 GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
00386 inline void PrintTo(char c, ::std::ostream* os) {
00387   // When printing a plain char, we always treat it as unsigned.  This
00388   // way, the output won't be affected by whether the compiler thinks
00389   // char is signed or not.
00390   PrintTo(static_cast<unsigned char>(c), os);
00391 }
00392 
00393 // Overloads for other simple built-in types.
00394 inline void PrintTo(bool x, ::std::ostream* os) {
00395   *os << (x ? "true" : "false");
00396 }
00397 
00398 // Overload for wchar_t type.
00399 // Prints a wchar_t as a symbol if it is printable or as its internal
00400 // code otherwise and also as its decimal code (except for L'\0').
00401 // The L'\0' char is printed as "L'\\0'". The decimal code is printed
00402 // as signed integer when wchar_t is implemented by the compiler
00403 // as a signed type and is printed as an unsigned integer when wchar_t
00404 // is implemented as an unsigned type.
00405 GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
00406 
00407 // Overloads for C strings.
00408 GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
00409 inline void PrintTo(char* s, ::std::ostream* os) {
00410   PrintTo(ImplicitCast_<const char*>(s), os);
00411 }
00412 
00413 // signed/unsigned char is often used for representing binary data, so
00414 // we print pointers to it as void* to be safe.
00415 inline void PrintTo(const signed char* s, ::std::ostream* os) {
00416   PrintTo(ImplicitCast_<const void*>(s), os);
00417 }
00418 inline void PrintTo(signed char* s, ::std::ostream* os) {
00419   PrintTo(ImplicitCast_<const void*>(s), os);
00420 }
00421 inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
00422   PrintTo(ImplicitCast_<const void*>(s), os);
00423 }
00424 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
00425   PrintTo(ImplicitCast_<const void*>(s), os);
00426 }
00427 
00428 // MSVC can be configured to define wchar_t as a typedef of unsigned
00429 // short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
00430 // type.  When wchar_t is a typedef, defining an overload for const
00431 // wchar_t* would cause unsigned short* be printed as a wide string,
00432 // possibly causing invalid memory accesses.
00433 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
00434 // Overloads for wide C strings
00435 GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
00436 inline void PrintTo(wchar_t* s, ::std::ostream* os) {
00437   PrintTo(ImplicitCast_<const wchar_t*>(s), os);
00438 }
00439 #endif
00440 
00441 // Overload for C arrays.  Multi-dimensional arrays are printed
00442 // properly.
00443 
00444 // Prints the given number of elements in an array, without printing
00445 // the curly braces.
00446 template <typename T>
00447 void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
00448   UniversalPrint(a[0], os);
00449   for (size_t i = 1; i != count; i++) {
00450     *os << ", ";
00451     UniversalPrint(a[i], os);
00452   }
00453 }
00454 
00455 // Overloads for ::string and ::std::string.
00456 #if GTEST_HAS_GLOBAL_STRING
00457 GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
00458 inline void PrintTo(const ::string& s, ::std::ostream* os) {
00459   PrintStringTo(s, os);
00460 }
00461 #endif  // GTEST_HAS_GLOBAL_STRING
00462 
00463 GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
00464 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
00465   PrintStringTo(s, os);
00466 }
00467 
00468 // Overloads for ::wstring and ::std::wstring.
00469 #if GTEST_HAS_GLOBAL_WSTRING
00470 GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
00471 inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
00472   PrintWideStringTo(s, os);
00473 }
00474 #endif  // GTEST_HAS_GLOBAL_WSTRING
00475 
00476 #if GTEST_HAS_STD_WSTRING
00477 GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
00478 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
00479   PrintWideStringTo(s, os);
00480 }
00481 #endif  // GTEST_HAS_STD_WSTRING
00482 
00483 #if GTEST_HAS_TR1_TUPLE
00484 // Overload for ::std::tr1::tuple.  Needed for printing function arguments,
00485 // which are packed as tuples.
00486 
00487 // Helper function for printing a tuple.  T must be instantiated with
00488 // a tuple type.
00489 template <typename T>
00490 void PrintTupleTo(const T& t, ::std::ostream* os);
00491 
00492 // Overloaded PrintTo() for tuples of various arities.  We support
00493 // tuples of up-to 10 fields.  The following implementation works
00494 // regardless of whether tr1::tuple is implemented using the
00495 // non-standard variadic template feature or not.
00496 
00497 inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
00498   PrintTupleTo(t, os);
00499 }
00500 
00501 template <typename T1>
00502 void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
00503   PrintTupleTo(t, os);
00504 }
00505 
00506 template <typename T1, typename T2>
00507 void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
00508   PrintTupleTo(t, os);
00509 }
00510 
00511 template <typename T1, typename T2, typename T3>
00512 void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
00513   PrintTupleTo(t, os);
00514 }
00515 
00516 template <typename T1, typename T2, typename T3, typename T4>
00517 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
00518   PrintTupleTo(t, os);
00519 }
00520 
00521 template <typename T1, typename T2, typename T3, typename T4, typename T5>
00522 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
00523              ::std::ostream* os) {
00524   PrintTupleTo(t, os);
00525 }
00526 
00527 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00528           typename T6>
00529 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
00530              ::std::ostream* os) {
00531   PrintTupleTo(t, os);
00532 }
00533 
00534 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00535           typename T6, typename T7>
00536 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
00537              ::std::ostream* os) {
00538   PrintTupleTo(t, os);
00539 }
00540 
00541 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00542           typename T6, typename T7, typename T8>
00543 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
00544              ::std::ostream* os) {
00545   PrintTupleTo(t, os);
00546 }
00547 
00548 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00549           typename T6, typename T7, typename T8, typename T9>
00550 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
00551              ::std::ostream* os) {
00552   PrintTupleTo(t, os);
00553 }
00554 
00555 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00556           typename T6, typename T7, typename T8, typename T9, typename T10>
00557 void PrintTo(
00558     const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
00559     ::std::ostream* os) {
00560   PrintTupleTo(t, os);
00561 }
00562 #endif  // GTEST_HAS_TR1_TUPLE
00563 
00564 // Overload for std::pair.
00565 template <typename T1, typename T2>
00566 void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
00567   *os << '(';
00568   // We cannot use UniversalPrint(value.first, os) here, as T1 may be
00569   // a reference type.  The same for printing value.second.
00570   UniversalPrinter<T1>::Print(value.first, os);
00571   *os << ", ";
00572   UniversalPrinter<T2>::Print(value.second, os);
00573   *os << ')';
00574 }
00575 
00576 // Implements printing a non-reference type T by letting the compiler
00577 // pick the right overload of PrintTo() for T.
00578 template <typename T>
00579 class UniversalPrinter {
00580  public:
00581   // MSVC warns about adding const to a function type, so we want to
00582   // disable the warning.
00583 #ifdef _MSC_VER
00584 # pragma warning(push)          // Saves the current warning state.
00585 # pragma warning(disable:4180)  // Temporarily disables warning 4180.
00586 #endif  // _MSC_VER
00587 
00588   // Note: we deliberately don't call this PrintTo(), as that name
00589   // conflicts with ::testing::internal::PrintTo in the body of the
00590   // function.
00591   static void Print(const T& value, ::std::ostream* os) {
00592     // By default, ::testing::internal::PrintTo() is used for printing
00593     // the value.
00594     //
00595     // Thanks to Koenig look-up, if T is a class and has its own
00596     // PrintTo() function defined in its namespace, that function will
00597     // be visible here.  Since it is more specific than the generic ones
00598     // in ::testing::internal, it will be picked by the compiler in the
00599     // following statement - exactly what we want.
00600     PrintTo(value, os);
00601   }
00602 
00603 #ifdef _MSC_VER
00604 # pragma warning(pop)           // Restores the warning state.
00605 #endif  // _MSC_VER
00606 };
00607 
00608 // UniversalPrintArray(begin, len, os) prints an array of 'len'
00609 // elements, starting at address 'begin'.
00610 template <typename T>
00611 void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
00612   if (len == 0) {
00613     *os << "{}";
00614   } else {
00615     *os << "{ ";
00616     const size_t kThreshold = 18;
00617     const size_t kChunkSize = 8;
00618     // If the array has more than kThreshold elements, we'll have to
00619     // omit some details by printing only the first and the last
00620     // kChunkSize elements.
00621     // TODO(wan@google.com): let the user control the threshold using a flag.
00622     if (len <= kThreshold) {
00623       PrintRawArrayTo(begin, len, os);
00624     } else {
00625       PrintRawArrayTo(begin, kChunkSize, os);
00626       *os << ", ..., ";
00627       PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
00628     }
00629     *os << " }";
00630   }
00631 }
00632 // This overload prints a (const) char array compactly.
00633 GTEST_API_ void UniversalPrintArray(
00634     const char* begin, size_t len, ::std::ostream* os);
00635 
00636 // This overload prints a (const) wchar_t array compactly.
00637 GTEST_API_ void UniversalPrintArray(
00638     const wchar_t* begin, size_t len, ::std::ostream* os);
00639 
00640 // Implements printing an array type T[N].
00641 template <typename T, size_t N>
00642 class UniversalPrinter<T[N]> {
00643  public:
00644   // Prints the given array, omitting some elements when there are too
00645   // many.
00646   static void Print(const T (&a)[N], ::std::ostream* os) {
00647     UniversalPrintArray(a, N, os);
00648   }
00649 };
00650 
00651 // Implements printing a reference type T&.
00652 template <typename T>
00653 class UniversalPrinter<T&> {
00654  public:
00655   // MSVC warns about adding const to a function type, so we want to
00656   // disable the warning.
00657 #ifdef _MSC_VER
00658 # pragma warning(push)          // Saves the current warning state.
00659 # pragma warning(disable:4180)  // Temporarily disables warning 4180.
00660 #endif  // _MSC_VER
00661 
00662   static void Print(const T& value, ::std::ostream* os) {
00663     // Prints the address of the value.  We use reinterpret_cast here
00664     // as static_cast doesn't compile when T is a function type.
00665     *os << "@" << reinterpret_cast<const void*>(&value) << " ";
00666 
00667     // Then prints the value itself.
00668     UniversalPrint(value, os);
00669   }
00670 
00671 #ifdef _MSC_VER
00672 # pragma warning(pop)           // Restores the warning state.
00673 #endif  // _MSC_VER
00674 };
00675 
00676 // Prints a value tersely: for a reference type, the referenced value
00677 // (but not the address) is printed; for a (const) char pointer, the
00678 // NUL-terminated string (but not the pointer) is printed.
00679 
00680 template <typename T>
00681 class UniversalTersePrinter {
00682  public:
00683   static void Print(const T& value, ::std::ostream* os) {
00684     UniversalPrint(value, os);
00685   }
00686 };
00687 template <typename T>
00688 class UniversalTersePrinter<T&> {
00689  public:
00690   static void Print(const T& value, ::std::ostream* os) {
00691     UniversalPrint(value, os);
00692   }
00693 };
00694 template <typename T, size_t N>
00695 class UniversalTersePrinter<T[N]> {
00696  public:
00697   static void Print(const T (&value)[N], ::std::ostream* os) {
00698     UniversalPrinter<T[N]>::Print(value, os);
00699   }
00700 };
00701 template <>
00702 class UniversalTersePrinter<const char*> {
00703  public:
00704   static void Print(const char* str, ::std::ostream* os) {
00705     if (str == NULL) {
00706       *os << "NULL";
00707     } else {
00708       UniversalPrint(string(str), os);
00709     }
00710   }
00711 };
00712 template <>
00713 class UniversalTersePrinter<char*> {
00714  public:
00715   static void Print(char* str, ::std::ostream* os) {
00716     UniversalTersePrinter<const char*>::Print(str, os);
00717   }
00718 };
00719 
00720 #if GTEST_HAS_STD_WSTRING
00721 template <>
00722 class UniversalTersePrinter<const wchar_t*> {
00723  public:
00724   static void Print(const wchar_t* str, ::std::ostream* os) {
00725     if (str == NULL) {
00726       *os << "NULL";
00727     } else {
00728       UniversalPrint(::std::wstring(str), os);
00729     }
00730   }
00731 };
00732 #endif
00733 
00734 template <>
00735 class UniversalTersePrinter<wchar_t*> {
00736  public:
00737   static void Print(wchar_t* str, ::std::ostream* os) {
00738     UniversalTersePrinter<const wchar_t*>::Print(str, os);
00739   }
00740 };
00741 
00742 template <typename T>
00743 void UniversalTersePrint(const T& value, ::std::ostream* os) {
00744   UniversalTersePrinter<T>::Print(value, os);
00745 }
00746 
00747 // Prints a value using the type inferred by the compiler.  The
00748 // difference between this and UniversalTersePrint() is that for a
00749 // (const) char pointer, this prints both the pointer and the
00750 // NUL-terminated string.
00751 template <typename T>
00752 void UniversalPrint(const T& value, ::std::ostream* os) {
00753   // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
00754   // UniversalPrinter with T directly.
00755   typedef T T1;
00756   UniversalPrinter<T1>::Print(value, os);
00757 }
00758 
00759 #if GTEST_HAS_TR1_TUPLE
00760 typedef ::std::vector<string> Strings;
00761 
00762 // This helper template allows PrintTo() for tuples and
00763 // UniversalTersePrintTupleFieldsToStrings() to be defined by
00764 // induction on the number of tuple fields.  The idea is that
00765 // TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
00766 // fields in tuple t, and can be defined in terms of
00767 // TuplePrefixPrinter<N - 1>.
00768 
00769 // The inductive case.
00770 template <size_t N>
00771 struct TuplePrefixPrinter {
00772   // Prints the first N fields of a tuple.
00773   template <typename Tuple>
00774   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
00775     TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
00776     *os << ", ";
00777     UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type>
00778         ::Print(::std::tr1::get<N - 1>(t), os);
00779   }
00780 
00781   // Tersely prints the first N fields of a tuple to a string vector,
00782   // one element for each field.
00783   template <typename Tuple>
00784   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
00785     TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
00786     ::std::stringstream ss;
00787     UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss);
00788     strings->push_back(ss.str());
00789   }
00790 };
00791 
00792 // Base cases.
00793 template <>
00794 struct TuplePrefixPrinter<0> {
00795   template <typename Tuple>
00796   static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
00797 
00798   template <typename Tuple>
00799   static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
00800 };
00801 // We have to specialize the entire TuplePrefixPrinter<> class
00802 // template here, even though the definition of
00803 // TersePrintPrefixToStrings() is the same as the generic version, as
00804 // Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't
00805 // support specializing a method template of a class template.
00806 template <>
00807 struct TuplePrefixPrinter<1> {
00808   template <typename Tuple>
00809   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
00810     UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>::
00811         Print(::std::tr1::get<0>(t), os);
00812   }
00813 
00814   template <typename Tuple>
00815   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
00816     ::std::stringstream ss;
00817     UniversalTersePrint(::std::tr1::get<0>(t), &ss);
00818     strings->push_back(ss.str());
00819   }
00820 };
00821 
00822 // Helper function for printing a tuple.  T must be instantiated with
00823 // a tuple type.
00824 template <typename T>
00825 void PrintTupleTo(const T& t, ::std::ostream* os) {
00826   *os << "(";
00827   TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>::
00828       PrintPrefixTo(t, os);
00829   *os << ")";
00830 }
00831 
00832 // Prints the fields of a tuple tersely to a string vector, one
00833 // element for each field.  See the comment before
00834 // UniversalTersePrint() for how we define "tersely".
00835 template <typename Tuple>
00836 Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
00837   Strings result;
00838   TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>::
00839       TersePrintPrefixToStrings(value, &result);
00840   return result;
00841 }
00842 #endif  // GTEST_HAS_TR1_TUPLE
00843 
00844 }  // namespace internal
00845 
00846 template <typename T>
00847 ::std::string PrintToString(const T& value) {
00848   ::std::stringstream ss;
00849   internal::UniversalTersePrinter<T>::Print(value, &ss);
00850   return ss.str();
00851 }
00852 
00853 }  // namespace testing
00854 
00855 #endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_