cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h File Reference

#include <functional>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-port.h"
#include "gtest/internal/custom/gtest-printers.h"

Include dependency graph for cmake-build-debug/googletest-src/googletest/include/gtest/gtest-printers.h:

Go to the source code of this file.

Classes
struct	testing::internal::ContainerPrinter
struct	testing::internal::FunctionPointerPrinter
struct	testing::internal::PointerPrinter
struct	testing::internal::internal_stream_operator_without_lexical_name_lookup::LookupBlocker
struct	testing::internal::internal_stream_operator_without_lexical_name_lookup::StreamPrinter
struct	testing::internal::ProtobufPrinter
struct	testing::internal::ConvertibleToIntegerPrinter
struct	testing::internal::ConvertibleToStringViewPrinter
struct	testing::internal::RawBytesPrinter
struct	testing::internal::FallbackPrinter
struct	testing::internal::FindFirstPrinter< T, E, Printer, Printers >
struct	testing::internal::FindFirstPrinter< T, decltype(Printer::PrintValue(std::declval< const T & >(), nullptr)), Printer, Printers... >
class	testing::internal::FormatForComparison< ToPrint, OtherOperand >
class	testing::internal::FormatForComparison< ToPrint[N], OtherOperand >
class	testing::internal::UniversalPrinter< T >
class	testing::internal::UniversalPrinter< const T >
class	testing::internal::UniversalPrinter< T[N]>
class	testing::internal::UniversalPrinter< T & >
class	testing::internal::UniversalTersePrinter< T >
class	testing::internal::UniversalTersePrinter< T & >
class	testing::internal::UniversalTersePrinter< T[N]>
class	testing::internal::UniversalTersePrinter< const char * >
class	testing::internal::UniversalTersePrinter< char * >
class	testing::internal::UniversalTersePrinter< wchar_t * >

Namespaces
	testing
	testing::internal
	testing::internal::internal_stream_operator_without_lexical_name_lookup

Macros
#define	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)
#define	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType)

Typedefs
typedef ::std::vector< ::std::string >	testing::internal::Strings

Functions
template<typename T >
void	testing::internal::UniversalPrint (const T &value, ::std::ostream *os)
void	testing::internal::internal_stream_operator_without_lexical_name_lookup::operator<< (LookupBlocker, LookupBlocker)
GTEST_API_ void	testing::internal::PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintWithFallback (const T &value, ::std::ostream *os)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char16_t)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char32_t)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char16_t, ::std::u16string)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char32_t, ::std::u32string)
template<typename T1 , typename T2 >
std::string	testing::internal::FormatForComparisonFailureMessage (const T1 &value, const T2 &)
template<typename T >
void	testing::internal::PrintTo (const T &value, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (unsigned char c, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (signed char c, ::std::ostream *os)
void	testing::internal::PrintTo (char c, ::std::ostream *os)
void	testing::internal::PrintTo (bool x, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (wchar_t wc, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (char32_t c, ::std::ostream *os)
void	testing::internal::PrintTo (char16_t c, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (const char *s, ::std::ostream *os)
void	testing::internal::PrintTo (char *s, ::std::ostream *os)
void	testing::internal::PrintTo (const signed char *s, ::std::ostream *os)
void	testing::internal::PrintTo (signed char *s, ::std::ostream *os)
void	testing::internal::PrintTo (const unsigned char *s, ::std::ostream *os)
void	testing::internal::PrintTo (unsigned char *s, ::std::ostream *os)
void	testing::internal::PrintTo (const char16_t *s, ::std::ostream *os)
void	testing::internal::PrintTo (char16_t *s, ::std::ostream *os)
void	testing::internal::PrintTo (const char32_t *s, ::std::ostream *os)
void	testing::internal::PrintTo (char32_t *s, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (const wchar_t *s, ::std::ostream *os)
void	testing::internal::PrintTo (wchar_t *s, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintRawArrayTo (const T a[], size_t count, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintStringTo (const ::std::string &s, ::std::ostream *os)
void	testing::internal::PrintTo (const ::std::string &s, ::std::ostream *os)
void	testing::internal::PrintTo (std::nullptr_t, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintTo (std::reference_wrapper< T > ref, ::std::ostream *os)
const void *	testing::internal::VoidifyPointer (const void *p)
const void *	testing::internal::VoidifyPointer (volatile const void *p)
template<typename T , typename Ptr >
void	testing::internal::PrintSmartPointer (const Ptr &ptr, std::ostream *os, char)
template<typename T , typename Ptr , typename = typename std::enable_if<!std::is_void<T>::value && !std::is_array<T>::value>::type>
void	testing::internal::PrintSmartPointer (const Ptr &ptr, std::ostream *os, int)
template<typename T , typename D >
void	testing::internal::PrintTo (const std::unique_ptr< T, D > &ptr, std::ostream *os)
template<typename T >
void	testing::internal::PrintTo (const std::shared_ptr< T > &ptr, std::ostream *os)
template<typename T >
void	testing::internal::PrintTupleTo (const T &, std::integral_constant< size_t, 0 >, ::std::ostream *)
template<typename T , size_t I>
void	testing::internal::PrintTupleTo (const T &t, std::integral_constant< size_t, I >, ::std::ostream *os)
template<typename... Types>
void	testing::internal::PrintTo (const ::std::tuple< Types... > &t, ::std::ostream *os)
template<typename T1 , typename T2 >
void	testing::internal::PrintTo (const ::std::pair< T1, T2 > &value, ::std::ostream *os)
template<typename T >
void	testing::internal::UniversalPrintArray (const T *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	testing::internal::UniversalPrintArray (const char *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	testing::internal::UniversalPrintArray (const wchar_t *begin, size_t len, ::std::ostream *os)
template<typename T >
void	testing::internal::UniversalTersePrint (const T &value, ::std::ostream *os)
template<typename Tuple >
void	testing::internal::TersePrintPrefixToStrings (const Tuple &, std::integral_constant< size_t, 0 >, Strings *)
template<typename Tuple , size_t I>
void	testing::internal::TersePrintPrefixToStrings (const Tuple &t, std::integral_constant< size_t, I >, Strings *strings)
template<typename Tuple >
Strings	testing::internal::UniversalTersePrintTupleFieldsToStrings (const Tuple &value)
template<typename T >
::std::string	testing::PrintToString (const T &value)

Macro Definition Documentation

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

CharType

)

Value:

  template <typename OtherOperand>                                      \
  class FormatForComparison<CharType*, OtherOperand> {                  \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(static_cast<const void*>(value)); \
    }                                                                   \
  }

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_

#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(		CharType,
			OtherStringType
	)

Value:

  template <>                                                           \
  class FormatForComparison<CharType*, OtherStringType> {               \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(value);                           \
    }                                                                   \
  }