GrPPI  1.0
Generic and Reusable Parallel Pattern Interface
cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h
Go to the documentation of this file.
1 // Copyright 2007, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 
30 
31 // Google Test - The Google C++ Testing and Mocking Framework
32 //
33 // This file implements a universal value printer that can print a
34 // value of any type T:
35 //
36 // void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
37 //
38 // A user can teach this function how to print a class type T by
39 // defining either operator<<() or PrintTo() in the namespace that
40 // defines T. More specifically, the FIRST defined function in the
41 // following list will be used (assuming T is defined in namespace
42 // foo):
43 //
44 // 1. foo::PrintTo(const T&, ostream*)
45 // 2. operator<<(ostream&, const T&) defined in either foo or the
46 // global namespace.
47 //
48 // However if T is an STL-style container then it is printed element-wise
49 // unless foo::PrintTo(const T&, ostream*) is defined. Note that
50 // operator<<() is ignored for container types.
51 //
52 // If none of the above is defined, it will print the debug string of
53 // the value if it is a protocol buffer, or print the raw bytes in the
54 // value otherwise.
55 //
56 // To aid debugging: when T is a reference type, the address of the
57 // value is also printed; when T is a (const) char pointer, both the
58 // pointer value and the NUL-terminated string it points to are
59 // printed.
60 //
61 // We also provide some convenient wrappers:
62 //
63 // // Prints a value to a string. For a (const or not) char
64 // // pointer, the NUL-terminated string (but not the pointer) is
65 // // printed.
66 // std::string ::testing::PrintToString(const T& value);
67 //
68 // // Prints a value tersely: for a reference type, the referenced
69 // // value (but not the address) is printed; for a (const or not) char
70 // // pointer, the NUL-terminated string (but not the pointer) is
71 // // printed.
72 // void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
73 //
74 // // Prints value using the type inferred by the compiler. The difference
75 // // from UniversalTersePrint() is that this function prints both the
76 // // pointer and the NUL-terminated string for a (const or not) char pointer.
77 // void ::testing::internal::UniversalPrint(const T& value, ostream*);
78 //
79 // // Prints the fields of a tuple tersely to a string vector, one
80 // // element for each field. Tuple support must be enabled in
81 // // gtest-port.h.
82 // std::vector<string> UniversalTersePrintTupleFieldsToStrings(
83 // const Tuple& value);
84 //
85 // Known limitation:
86 //
87 // The print primitives print the elements of an STL-style container
88 // using the compiler-inferred type of *iter where iter is a
89 // const_iterator of the container. When const_iterator is an input
90 // iterator but not a forward iterator, this inferred type may not
91 // match value_type, and the print output may be incorrect. In
92 // practice, this is rarely a problem as for most containers
93 // const_iterator is a forward iterator. We'll fix this if there's an
94 // actual need for it. Note that this fix cannot rely on value_type
95 // being defined as many user-defined container types don't have
96 // value_type.
97 
98 // GOOGLETEST_CM0001 DO NOT DELETE
99 
100 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
101 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
102 
103 #include <functional>
104 #include <memory>
105 #include <ostream> // NOLINT
106 #include <sstream>
107 #include <string>
108 #include <tuple>
109 #include <type_traits>
110 #include <utility>
111 #include <vector>
112 
113 #include "gtest/internal/gtest-internal.h"
114 #include "gtest/internal/gtest-port.h"
115 
116 namespace testing {
117 
118 // Definitions in the internal* namespaces are subject to change without notice.
119 // DO NOT USE THEM IN USER CODE!
120 namespace internal {
121 
122 template <typename T>
123 void UniversalPrint(const T& value, ::std::ostream* os);
124 
125 // Used to print an STL-style container when the user doesn't define
126 // a PrintTo() for it.
128  template <typename T,
129  typename = typename std::enable_if<
130  (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
132  static void PrintValue(const T& container, std::ostream* os) {
133  const size_t kMaxCount = 32; // The maximum number of elements to print.
134  *os << '{';
135  size_t count = 0;
136  for (auto&& elem : container) {
137  if (count > 0) {
138  *os << ',';
139  if (count == kMaxCount) { // Enough has been printed.
140  *os << " ...";
141  break;
142  }
143  }
144  *os << ' ';
145  // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
146  // handle `elem` being a native array.
147  internal::UniversalPrint(elem, os);
148  ++count;
149  }
150 
151  if (count > 0) {
152  *os << ' ';
153  }
154  *os << '}';
155  }
156 };
157 
158 // Used to print a pointer that is neither a char pointer nor a member
159 // pointer, when the user doesn't define PrintTo() for it. (A member
160 // variable pointer or member function pointer doesn't really point to
161 // a location in the address space. Their representation is
162 // implementation-defined. Therefore they will be printed as raw
163 // bytes.)
165  template <typename T, typename = typename std::enable_if<
166  std::is_function<T>::value>::type>
167  static void PrintValue(T* p, ::std::ostream* os) {
168  if (p == nullptr) {
169  *os << "NULL";
170  } else {
171  // T is a function type, so '*os << p' doesn't do what we want
172  // (it just prints p as bool). We want to print p as a const
173  // void*.
174  *os << reinterpret_cast<const void*>(p);
175  }
176  }
177 };
178 
180  template <typename T>
181  static void PrintValue(T* p, ::std::ostream* os) {
182  if (p == nullptr) {
183  *os << "NULL";
184  } else {
185  // T is not a function type. We just call << to print p,
186  // relying on ADL to pick up user-defined << for their pointer
187  // types, if any.
188  *os << p;
189  }
190  }
191 };
192 
193 namespace internal_stream_operator_without_lexical_name_lookup {
194 
195 // The presence of an operator<< here will terminate lexical scope lookup
196 // straight away (even though it cannot be a match because of its argument
197 // types). Thus, the two operator<< calls in StreamPrinter will find only ADL
198 // candidates.
199 struct LookupBlocker {};
201 
203  template <typename T,
204  // Don't accept member pointers here. We'd print them via implicit
205  // conversion to bool, which isn't useful.
206  typename = typename std::enable_if<
207  !std::is_member_pointer<T>::value>::type,
208  // Only accept types for which we can find a streaming operator via
209  // ADL (possibly involving implicit conversions).
210  typename = decltype(std::declval<std::ostream&>()
211  << std::declval<const T&>())>
212  static void PrintValue(const T& value, ::std::ostream* os) {
213  // Call streaming operator found by ADL, possibly with implicit conversions
214  // of the arguments.
215  *os << value;
216  }
217 };
218 
219 } // namespace internal_stream_operator_without_lexical_name_lookup
220 
222  // We print a protobuf using its ShortDebugString() when the string
223  // doesn't exceed this many characters; otherwise we print it using
224  // DebugString() for better readability.
225  static const size_t kProtobufOneLinerMaxLength = 50;
226 
227  template <typename T,
228  typename = typename std::enable_if<
230  static void PrintValue(const T& value, ::std::ostream* os) {
231  std::string pretty_str = value.ShortDebugString();
232  if (pretty_str.length() > kProtobufOneLinerMaxLength) {
233  pretty_str = "\n" + value.DebugString();
234  }
235  *os << ("<" + pretty_str + ">");
236  }
237 };
238 
240  // Since T has no << operator or PrintTo() but can be implicitly
241  // converted to BiggestInt, we print it as a BiggestInt.
242  //
243  // Most likely T is an enum type (either named or unnamed), in which
244  // case printing it as an integer is the desired behavior. In case
245  // T is not an enum, printing it as an integer is the best we can do
246  // given that it has no user-defined printer.
247  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
248  *os << value;
249  }
250 };
251 
253 #if GTEST_INTERNAL_HAS_STRING_VIEW
254  static void PrintValue(internal::StringView value, ::std::ostream* os) {
255  internal::UniversalPrint(value, os);
256  }
257 #endif
258 };
259 
260 
261 // Prints the given number of bytes in the given object to the given
262 // ostream.
263 GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
264  size_t count,
265  ::std::ostream* os);
267  // SFINAE on `sizeof` to make sure we have a complete type.
268  template <typename T, size_t = sizeof(T)>
269  static void PrintValue(const T& value, ::std::ostream* os) {
271  static_cast<const unsigned char*>(
272  // Load bearing cast to void* to support iOS
273  reinterpret_cast<const void*>(std::addressof(value))),
274  sizeof(value), os);
275  }
276 };
277 
279  template <typename T>
280  static void PrintValue(const T&, ::std::ostream* os) {
281  *os << "(incomplete type)";
282  }
283 };
284 
285 // Try every printer in order and return the first one that works.
286 template <typename T, typename E, typename Printer, typename... Printers>
287 struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
288 
289 template <typename T, typename Printer, typename... Printers>
291  T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
292  Printer, Printers...> {
293  using type = Printer;
294 };
295 
296 // Select the best printer in the following order:
297 // - Print containers (they have begin/end/etc).
298 // - Print function pointers.
299 // - Print object pointers.
300 // - Use the stream operator, if available.
301 // - Print protocol buffers.
302 // - Print types convertible to BiggestInt.
303 // - Print types convertible to StringView, if available.
304 // - Fallback to printing the raw bytes of the object.
305 template <typename T>
306 void PrintWithFallback(const T& value, ::std::ostream* os) {
307  using Printer = typename FindFirstPrinter<
312  Printer::PrintValue(value, os);
313 }
314 
315 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
316 // value of type ToPrint that is an operand of a comparison assertion
317 // (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in
318 // the comparison, and is used to help determine the best way to
319 // format the value. In particular, when the value is a C string
320 // (char pointer) and the other operand is an STL string object, we
321 // want to format the C string as a string, since we know it is
322 // compared by value with the string object. If the value is a char
323 // pointer but the other operand is not an STL string object, we don't
324 // know whether the pointer is supposed to point to a NUL-terminated
325 // string, and thus want to print it as a pointer to be safe.
326 //
327 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
328 
329 // The default case.
330 template <typename ToPrint, typename OtherOperand>
332  public:
333  static ::std::string Format(const ToPrint& value) {
335  }
336 };
337 
338 // Array.
339 template <typename ToPrint, size_t N, typename OtherOperand>
340 class FormatForComparison<ToPrint[N], OtherOperand> {
341  public:
342  static ::std::string Format(const ToPrint* value) {
344  }
345 };
346 
347 // By default, print C string as pointers to be safe, as we don't know
348 // whether they actually point to a NUL-terminated string.
349 
350 #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \
351  template <typename OtherOperand> \
352  class FormatForComparison<CharType*, OtherOperand> { \
353  public: \
354  static ::std::string Format(CharType* value) { \
355  return ::testing::PrintToString(static_cast<const void*>(value)); \
356  } \
357  }
358 
363 #ifdef __cpp_char8_t
366 #endif
371 
372 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
373 
374 // If a C string is compared with an STL string object, we know it's meant
375 // to point to a NUL-terminated string, and thus can print it as a string.
376 
377 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
378  template <> \
379  class FormatForComparison<CharType*, OtherStringType> { \
380  public: \
381  static ::std::string Format(CharType* value) { \
382  return ::testing::PrintToString(value); \
383  } \
384  }
385 
387 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
388 #ifdef __cpp_char8_t
389 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
390 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
391 #endif
392 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
393 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
394 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
395 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);
396 
397 #if GTEST_HAS_STD_WSTRING
398 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
399 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
400 #endif
401 
402 #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
403 
404 // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
405 // operand to be used in a failure message. The type (but not value)
406 // of the other operand may affect the format. This allows us to
407 // print a char* as a raw pointer when it is compared against another
408 // char* or void*, and print it as a C string when it is compared
409 // against an std::string object, for example.
410 //
411 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
412 template <typename T1, typename T2>
414  const T1& value, const T2& /* other_operand */) {
416 }
417 
418 // UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
419 // value to the given ostream. The caller must ensure that
420 // 'ostream_ptr' is not NULL, or the behavior is undefined.
421 //
422 // We define UniversalPrinter as a class template (as opposed to a
423 // function template), as we need to partially specialize it for
424 // reference types, which cannot be done with function templates.
425 template <typename T>
426 class UniversalPrinter;
427 
428 // Prints the given value using the << operator if it has one;
429 // otherwise prints the bytes in it. This is what
430 // UniversalPrinter<T>::Print() does when PrintTo() is not specialized
431 // or overloaded for type T.
432 //
433 // A user can override this behavior for a class type Foo by defining
434 // an overload of PrintTo() in the namespace where Foo is defined. We
435 // give the user this option as sometimes defining a << operator for
436 // Foo is not desirable (e.g. the coding style may prevent doing it,
437 // or there is already a << operator but it doesn't do what the user
438 // wants).
439 template <typename T>
440 void PrintTo(const T& value, ::std::ostream* os) {
441  internal::PrintWithFallback(value, os);
442 }
443 
444 // The following list of PrintTo() overloads tells
445 // UniversalPrinter<T>::Print() how to print standard types (built-in
446 // types, strings, plain arrays, and pointers).
447 
448 // Overloads for various char types.
449 GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
450 GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
451 inline void PrintTo(char c, ::std::ostream* os) {
452  // When printing a plain char, we always treat it as unsigned. This
453  // way, the output won't be affected by whether the compiler thinks
454  // char is signed or not.
455  PrintTo(static_cast<unsigned char>(c), os);
456 }
457 
458 // Overloads for other simple built-in types.
459 inline void PrintTo(bool x, ::std::ostream* os) {
460  *os << (x ? "true" : "false");
461 }
462 
463 // Overload for wchar_t type.
464 // Prints a wchar_t as a symbol if it is printable or as its internal
465 // code otherwise and also as its decimal code (except for L'\0').
466 // The L'\0' char is printed as "L'\\0'". The decimal code is printed
467 // as signed integer when wchar_t is implemented by the compiler
468 // as a signed type and is printed as an unsigned integer when wchar_t
469 // is implemented as an unsigned type.
470 GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
471 
472 GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
473 inline void PrintTo(char16_t c, ::std::ostream* os) {
474  PrintTo(ImplicitCast_<char32_t>(c), os);
475 }
476 #ifdef __cpp_char8_t
477 inline void PrintTo(char8_t c, ::std::ostream* os) {
478  PrintTo(ImplicitCast_<char32_t>(c), os);
479 }
480 #endif
481 
482 // Overloads for C strings.
483 GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
484 inline void PrintTo(char* s, ::std::ostream* os) {
485  PrintTo(ImplicitCast_<const char*>(s), os);
486 }
487 
488 // signed/unsigned char is often used for representing binary data, so
489 // we print pointers to it as void* to be safe.
490 inline void PrintTo(const signed char* s, ::std::ostream* os) {
491  PrintTo(ImplicitCast_<const void*>(s), os);
492 }
493 inline void PrintTo(signed char* s, ::std::ostream* os) {
494  PrintTo(ImplicitCast_<const void*>(s), os);
495 }
496 inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
497  PrintTo(ImplicitCast_<const void*>(s), os);
498 }
499 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
500  PrintTo(ImplicitCast_<const void*>(s), os);
501 }
502 #ifdef __cpp_char8_t
503 inline void PrintTo(const char8_t* s, ::std::ostream* os) {
504  PrintTo(ImplicitCast_<const void*>(s), os);
505 }
506 inline void PrintTo(char8_t* s, ::std::ostream* os) {
507  PrintTo(ImplicitCast_<const void*>(s), os);
508 }
509 #endif
510 inline void PrintTo(const char16_t* s, ::std::ostream* os) {
511  PrintTo(ImplicitCast_<const void*>(s), os);
512 }
513 inline void PrintTo(char16_t* s, ::std::ostream* os) {
514  PrintTo(ImplicitCast_<const void*>(s), os);
515 }
516 inline void PrintTo(const char32_t* s, ::std::ostream* os) {
517  PrintTo(ImplicitCast_<const void*>(s), os);
518 }
519 inline void PrintTo(char32_t* s, ::std::ostream* os) {
520  PrintTo(ImplicitCast_<const void*>(s), os);
521 }
522 
523 // MSVC can be configured to define wchar_t as a typedef of unsigned
524 // short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
525 // type. When wchar_t is a typedef, defining an overload for const
526 // wchar_t* would cause unsigned short* be printed as a wide string,
527 // possibly causing invalid memory accesses.
528 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
529 // Overloads for wide C strings
530 GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
531 inline void PrintTo(wchar_t* s, ::std::ostream* os) {
532  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
533 }
534 #endif
535 
536 // Overload for C arrays. Multi-dimensional arrays are printed
537 // properly.
538 
539 // Prints the given number of elements in an array, without printing
540 // the curly braces.
541 template <typename T>
542 void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
543  UniversalPrint(a[0], os);
544  for (size_t i = 1; i != count; i++) {
545  *os << ", ";
546  UniversalPrint(a[i], os);
547  }
548 }
549 
550 // Overloads for ::std::string.
551 GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
552 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
553  PrintStringTo(s, os);
554 }
555 
556 // Overloads for ::std::wstring.
557 #if GTEST_HAS_STD_WSTRING
558 GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
559 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
560  PrintWideStringTo(s, os);
561 }
562 #endif // GTEST_HAS_STD_WSTRING
563 
564 #if GTEST_INTERNAL_HAS_STRING_VIEW
565 // Overload for internal::StringView.
566 inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
567  PrintTo(::std::string(sp), os);
568 }
569 #endif // GTEST_INTERNAL_HAS_STRING_VIEW
570 
571 inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
572 
573 template <typename T>
574 void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
575  UniversalPrinter<T&>::Print(ref.get(), os);
576 }
577 
578 inline const void* VoidifyPointer(const void* p) { return p; }
579 inline const void* VoidifyPointer(volatile const void* p) {
580  return const_cast<const void*>(p);
581 }
582 
583 template <typename T, typename Ptr>
584 void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
585  if (ptr == nullptr) {
586  *os << "(nullptr)";
587  } else {
588  // We can't print the value. Just print the pointer..
589  *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
590  }
591 }
592 template <typename T, typename Ptr,
593  typename = typename std::enable_if<!std::is_void<T>::value &&
594  !std::is_array<T>::value>::type>
595 void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
596  if (ptr == nullptr) {
597  *os << "(nullptr)";
598  } else {
599  *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
600  UniversalPrinter<T>::Print(*ptr, os);
601  *os << ")";
602  }
603 }
604 
605 template <typename T, typename D>
606 void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
607  (PrintSmartPointer<T>)(ptr, os, 0);
608 }
609 
610 template <typename T>
611 void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
612  (PrintSmartPointer<T>)(ptr, os, 0);
613 }
614 
615 // Helper function for printing a tuple. T must be instantiated with
616 // a tuple type.
617 template <typename T>
618 void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
619  ::std::ostream*) {}
620 
621 template <typename T, size_t I>
622 void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
623  ::std::ostream* os) {
624  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
626  if (I > 1) {
628  *os << ", ";
629  }
630  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
631  std::get<I - 1>(t), os);
632 }
633 
634 template <typename... Types>
635 void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
636  *os << "(";
637  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
638  *os << ")";
639 }
640 
641 // Overload for std::pair.
642 template <typename T1, typename T2>
643 void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
644  *os << '(';
645  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
646  // a reference type. The same for printing value.second.
647  UniversalPrinter<T1>::Print(value.first, os);
648  *os << ", ";
649  UniversalPrinter<T2>::Print(value.second, os);
650  *os << ')';
651 }
652 
653 // Implements printing a non-reference type T by letting the compiler
654 // pick the right overload of PrintTo() for T.
655 template <typename T>
656 class UniversalPrinter {
657  public:
658  // MSVC warns about adding const to a function type, so we want to
659  // disable the warning.
661 
662  // Note: we deliberately don't call this PrintTo(), as that name
663  // conflicts with ::testing::internal::PrintTo in the body of the
664  // function.
665  static void Print(const T& value, ::std::ostream* os) {
666  // By default, ::testing::internal::PrintTo() is used for printing
667  // the value.
668  //
669  // Thanks to Koenig look-up, if T is a class and has its own
670  // PrintTo() function defined in its namespace, that function will
671  // be visible here. Since it is more specific than the generic ones
672  // in ::testing::internal, it will be picked by the compiler in the
673  // following statement - exactly what we want.
674  PrintTo(value, os);
675  }
676 
678 };
679 
680 // Remove any const-qualifiers before passing a type to UniversalPrinter.
681 template <typename T>
682 class UniversalPrinter<const T> : public UniversalPrinter<T> {};
683 
684 #if GTEST_INTERNAL_HAS_ANY
685 
686 // Printer for std::any / absl::any
687 
688 template <>
689 class UniversalPrinter<Any> {
690  public:
691  static void Print(const Any& value, ::std::ostream* os) {
692  if (value.has_value()) {
693  *os << "value of type " << GetTypeName(value);
694  } else {
695  *os << "no value";
696  }
697  }
698 
699  private:
700  static std::string GetTypeName(const Any& value) {
701 #if GTEST_HAS_RTTI
702  return internal::GetTypeName(value.type());
703 #else
704  static_cast<void>(value); // possibly unused
705  return "<unknown_type>";
706 #endif // GTEST_HAS_RTTI
707  }
708 };
709 
710 #endif // GTEST_INTERNAL_HAS_ANY
711 
712 #if GTEST_INTERNAL_HAS_OPTIONAL
713 
714 // Printer for std::optional / absl::optional
715 
716 template <typename T>
717 class UniversalPrinter<Optional<T>> {
718  public:
719  static void Print(const Optional<T>& value, ::std::ostream* os) {
720  *os << '(';
721  if (!value) {
722  *os << "nullopt";
723  } else {
724  UniversalPrint(*value, os);
725  }
726  *os << ')';
727  }
728 };
729 
730 #endif // GTEST_INTERNAL_HAS_OPTIONAL
731 
732 #if GTEST_INTERNAL_HAS_VARIANT
733 
734 // Printer for std::variant / absl::variant
735 
736 template <typename... T>
737 class UniversalPrinter<Variant<T...>> {
738  public:
739  static void Print(const Variant<T...>& value, ::std::ostream* os) {
740  *os << '(';
741 #if GTEST_HAS_ABSL
742  absl::visit(Visitor{os, value.index()}, value);
743 #else
744  std::visit(Visitor{os, value.index()}, value);
745 #endif // GTEST_HAS_ABSL
746  *os << ')';
747  }
748 
749  private:
750  struct Visitor {
751  template <typename U>
752  void operator()(const U& u) const {
753  *os << "'" << GetTypeName<U>() << "(index = " << index
754  << ")' with value ";
755  UniversalPrint(u, os);
756  }
757  ::std::ostream* os;
758  std::size_t index;
759  };
760 };
761 
762 #endif // GTEST_INTERNAL_HAS_VARIANT
763 
764 // UniversalPrintArray(begin, len, os) prints an array of 'len'
765 // elements, starting at address 'begin'.
766 template <typename T>
767 void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
768  if (len == 0) {
769  *os << "{}";
770  } else {
771  *os << "{ ";
772  const size_t kThreshold = 18;
773  const size_t kChunkSize = 8;
774  // If the array has more than kThreshold elements, we'll have to
775  // omit some details by printing only the first and the last
776  // kChunkSize elements.
777  if (len <= kThreshold) {
778  PrintRawArrayTo(begin, len, os);
779  } else {
780  PrintRawArrayTo(begin, kChunkSize, os);
781  *os << ", ..., ";
782  PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
783  }
784  *os << " }";
785  }
786 }
787 // This overload prints a (const) char array compactly.
789  const char* begin, size_t len, ::std::ostream* os);
790 
791 // This overload prints a (const) wchar_t array compactly.
793  const wchar_t* begin, size_t len, ::std::ostream* os);
794 
795 // Implements printing an array type T[N].
796 template <typename T, size_t N>
797 class UniversalPrinter<T[N]> {
798  public:
799  // Prints the given array, omitting some elements when there are too
800  // many.
801  static void Print(const T (&a)[N], ::std::ostream* os) {
802  UniversalPrintArray(a, N, os);
803  }
804 };
805 
806 // Implements printing a reference type T&.
807 template <typename T>
808 class UniversalPrinter<T&> {
809  public:
810  // MSVC warns about adding const to a function type, so we want to
811  // disable the warning.
813 
814  static void Print(const T& value, ::std::ostream* os) {
815  // Prints the address of the value. We use reinterpret_cast here
816  // as static_cast doesn't compile when T is a function type.
817  *os << "@" << reinterpret_cast<const void*>(&value) << " ";
818 
819  // Then prints the value itself.
820  UniversalPrint(value, os);
821  }
822 
824 };
825 
826 // Prints a value tersely: for a reference type, the referenced value
827 // (but not the address) is printed; for a (const) char pointer, the
828 // NUL-terminated string (but not the pointer) is printed.
829 
830 template <typename T>
832  public:
833  static void Print(const T& value, ::std::ostream* os) {
834  UniversalPrint(value, os);
835  }
836 };
837 template <typename T>
839  public:
840  static void Print(const T& value, ::std::ostream* os) {
841  UniversalPrint(value, os);
842  }
843 };
844 template <typename T, size_t N>
846  public:
847  static void Print(const T (&value)[N], ::std::ostream* os) {
849  }
850 };
851 template <>
852 class UniversalTersePrinter<const char*> {
853  public:
854  static void Print(const char* str, ::std::ostream* os) {
855  if (str == nullptr) {
856  *os << "NULL";
857  } else {
858  UniversalPrint(std::string(str), os);
859  }
860  }
861 };
862 template <>
863 class UniversalTersePrinter<char*> {
864  public:
865  static void Print(char* str, ::std::ostream* os) {
867  }
868 };
869 
870 #if GTEST_HAS_STD_WSTRING
871 template <>
872 class UniversalTersePrinter<const wchar_t*> {
873  public:
874  static void Print(const wchar_t* str, ::std::ostream* os) {
875  if (str == nullptr) {
876  *os << "NULL";
877  } else {
878  UniversalPrint(::std::wstring(str), os);
879  }
880  }
881 };
882 #endif
883 
884 template <>
885 class UniversalTersePrinter<wchar_t*> {
886  public:
887  static void Print(wchar_t* str, ::std::ostream* os) {
889  }
890 };
891 
892 template <typename T>
893 void UniversalTersePrint(const T& value, ::std::ostream* os) {
895 }
896 
897 // Prints a value using the type inferred by the compiler. The
898 // difference between this and UniversalTersePrint() is that for a
899 // (const) char pointer, this prints both the pointer and the
900 // NUL-terminated string.
901 template <typename T>
902 void UniversalPrint(const T& value, ::std::ostream* os) {
903  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
904  // UniversalPrinter with T directly.
905  typedef T T1;
906  UniversalPrinter<T1>::Print(value, os);
907 }
908 
909 typedef ::std::vector< ::std::string> Strings;
910 
911  // Tersely prints the first N fields of a tuple to a string vector,
912  // one element for each field.
913 template <typename Tuple>
914 void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
915  Strings*) {}
916 template <typename Tuple, size_t I>
917 void TersePrintPrefixToStrings(const Tuple& t,
918  std::integral_constant<size_t, I>,
919  Strings* strings) {
920  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
921  strings);
922  ::std::stringstream ss;
923  UniversalTersePrint(std::get<I - 1>(t), &ss);
924  strings->push_back(ss.str());
925 }
926 
927 // Prints the fields of a tuple tersely to a string vector, one
928 // element for each field. See the comment before
929 // UniversalTersePrint() for how we define "tersely".
930 template <typename Tuple>
932  Strings result;
934  value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
935  &result);
936  return result;
937 }
938 
939 } // namespace internal
940 
941 template <typename T>
942 ::std::string PrintToString(const T& value) {
943  ::std::stringstream ss;
945  return ss.str();
946 }
947 
948 } // namespace testing
949 
950 // Include any custom printer added by the local installation.
951 // We must include this header at the end to make sure it can use the
952 // declarations from this file.
953 #include "gtest/internal/custom/gtest-printers.h"
954 
955 #endif // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
::std::string Format(const ToPrint *value)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:342
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:331
::std::string Format(const ToPrint &value)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:333
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-internal.h:895
static void Print(const T(&a)[N], ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:801
Definition: cmake-build-release/googletest-src/googletest/include/gtest/gtest-printers.h:656
static void Print(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:665
static void Print(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:840
static void Print(const T(&value)[N], ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:847
static void Print(char *str, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:865
static void Print(const char *str, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:854
static void Print(wchar_t *str, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:887
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:831
static void Print(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:833
#define GTEST_INTENTIONAL_CONST_COND_PUSH_()
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-port.h:727
#define GTEST_API_
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-port.h:775
#define GTEST_INTENTIONAL_CONST_COND_POP_()
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-port.h:729
long long BiggestInt
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-port.h:2133
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251) class GTEST_API_ TypedTestSuitePState
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-internal.h:593
void UniversalPrint(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:902
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char)
::std::vector< ::std::string > Strings
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:909
void PrintSmartPointer(const Ptr &ptr, std::ostream *os, char)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:584
void PrintWithFallback(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:306
void TersePrintPrefixToStrings(const Tuple &, std::integral_constant< size_t, 0 >, Strings *)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:914
std::string GetTypeName()
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-type-util.h:93
const void * VoidifyPointer(const void *p)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:578
void PrintTupleTo(const T &, std::integral_constant< size_t, 0 >, ::std::ostream *)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:618
Strings UniversalTersePrintTupleFieldsToStrings(const Tuple &value)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:931
GTEST_API_ void PrintStringTo(const ::std::string &s, ::std::ostream *os)
std::string FormatForComparisonFailureMessage(const T1 &value, const T2 &)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:413
GTEST_API_ void PrintBytesInObjectTo(const unsigned char *obj_bytes, size_t count, ::std::ostream *os)
GTEST_DISABLE_MSC_WARNINGS_POP_() inline const char *SkipComma(const char *str)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-internal.h:648
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:542
void UniversalPrintArray(const T *begin, size_t len, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:767
int IsContainer
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-internal.h:944
void PrintTo(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:440
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string)
void UniversalTersePrint(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:893
Definition: cmake-build-debug/googletest-src/googlemock/include/gmock/gmock-actions.h:154
::std::string PrintToString(const T &value)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:942
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:127
static void PrintValue(const T &container, std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:132
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:239
static void PrintValue(internal::BiggestInt value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:247
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:252
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:278
static void PrintValue(const T &, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:280
Printer type
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:293
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:287
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:164
static void PrintValue(T *p, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:167
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-internal.h:1007
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:179
static void PrintValue(T *p, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:181
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:221
static const size_t kProtobufOneLinerMaxLength
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:225
static void PrintValue(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:230
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-type-util.h:153
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:266
static void PrintValue(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:269
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/internal/gtest-type-util.h:139
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:199
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:202
static void PrintValue(const T &value, ::std::ostream *os)
Definition: cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:212