"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/include/gtest/gtest-printers.h" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

gtest-printers.h  (googletest-release-1.11.0)	:	gtest-printers.h  (googletest-release-1.12.0)
skipping to change at line 97		skipping to change at line 97
// using the compiler-inferred type of *iter where iter is a		// using the compiler-inferred type of *iter where iter is a
// const_iterator of the container. When const_iterator is an input		// const_iterator of the container. When const_iterator is an input
// iterator but not a forward iterator, this inferred type may not		// iterator but not a forward iterator, this inferred type may not
// match value_type, and the print output may be incorrect. In		// match value_type, and the print output may be incorrect. In
// practice, this is rarely a problem as for most containers		// practice, this is rarely a problem as for most containers
// const_iterator is a forward iterator. We'll fix this if there's an		// const_iterator is a forward iterator. We'll fix this if there's an
// actual need for it. Note that this fix cannot rely on value_type		// actual need for it. Note that this fix cannot rely on value_type
// being defined as many user-defined container types don't have		// being defined as many user-defined container types don't have
// value_type.		// value_type.
// GOOGLETEST_CM0001 DO NOT DELETE		// IWYU pragma: private, include "gtest/gtest.h"
		// IWYU pragma: friend gtest/.*
		// IWYU pragma: friend gmock/.*
#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_		#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_		#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#include <functional>		#include <functional>
#include <memory>		#include <memory>
#include <ostream> // NOLINT		#include <ostream> // NOLINT
#include <sstream>		#include <sstream>
#include <string>		#include <string>
#include <tuple>		#include <tuple>
skipping to change at line 262		skipping to change at line 264
#if GTEST_INTERNAL_HAS_STRING_VIEW		#if GTEST_INTERNAL_HAS_STRING_VIEW
static void PrintValue(internal::StringView value, ::std::ostream* os) {		static void PrintValue(internal::StringView value, ::std::ostream* os) {
internal::UniversalPrint(value, os);		internal::UniversalPrint(value, os);
}		}
#endif		#endif
};		};
// Prints the given number of bytes in the given object to the given		// Prints the given number of bytes in the given object to the given
// ostream.		// ostream.
GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,		GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
size_t count,		size_t count, ::std::ostream* os);
::std::ostream* os);
struct RawBytesPrinter {		struct RawBytesPrinter {
// SFINAE on `sizeof` to make sure we have a complete type.		// SFINAE on `sizeof` to make sure we have a complete type.
template <typename T, size_t = sizeof(T)>		template <typename T, size_t = sizeof(T)>
static void PrintValue(const T& value, ::std::ostream* os) {		static void PrintValue(const T& value, ::std::ostream* os) {
PrintBytesInObjectTo(		PrintBytesInObjectTo(
static_cast<const unsigned char*>(		static_cast<const unsigned char*>(
// Load bearing cast to void* to support iOS		// Load bearing cast to void* to support iOS
reinterpret_cast<const void*>(std::addressof(value))),		reinterpret_cast<const void*>(std::addressof(value))),
sizeof(value), os);		sizeof(value), os);
}		}
skipping to change at line 361		skipping to change at line 362
public: \		public: \
static ::std::string Format(CharType* value) { \		static ::std::string Format(CharType* value) { \
return ::testing::PrintToString(static_cast<const void*>(value)); \		return ::testing::PrintToString(static_cast<const void*>(value)); \
} \		} \
}		}
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
#ifdef __cpp_char8_t		#ifdef __cpp_lib_char8_t
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
#endif		#endif
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);		GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_		#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
// If a C string is compared with an STL string object, we know it's meant		// If a C string is compared with an STL string object, we know it's meant
// to point to a NUL-terminated string, and thus can print it as a string.		// to point to a NUL-terminated string, and thus can print it as a string.
#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \		#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
template <> \		template <> \
class FormatForComparison<CharType*, OtherStringType> { \		class FormatForComparison<CharType*, OtherStringType> { \
public: \		public: \
static ::std::string Format(CharType* value) { \		static ::std::string Format(CharType* value) { \
return ::testing::PrintToString(value); \		return ::testing::PrintToString(value); \
} \		} \
}		}
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
#ifdef __cpp_char8_t		#ifdef __cpp_char8_t
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
#endif		#endif
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);		GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
skipping to change at line 411		skipping to change at line 412
// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)		// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
// operand to be used in a failure message. The type (but not value)		// operand to be used in a failure message. The type (but not value)
// of the other operand may affect the format. This allows us to		// of the other operand may affect the format. This allows us to
// print a char* as a raw pointer when it is compared against another		// print a char* as a raw pointer when it is compared against another
// char* or void*, and print it as a C string when it is compared		// char* or void*, and print it as a C string when it is compared
// against an std::string object, for example.		// against an std::string object, for example.
//		//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.		// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename T1, typename T2>		template <typename T1, typename T2>
std::string FormatForComparisonFailureMessage(		std::string FormatForComparisonFailureMessage(const T1& value,
const T1& value, const T2& /* other_operand */) {		const T2& /* other_operand */) {
return FormatForComparison<T1, T2>::Format(value);		return FormatForComparison<T1, T2>::Format(value);
}		}
// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given		// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
// value to the given ostream. The caller must ensure that		// value to the given ostream. The caller must ensure that
// 'ostream_ptr' is not NULL, or the behavior is undefined.		// 'ostream_ptr' is not NULL, or the behavior is undefined.
//		//
// We define UniversalPrinter as a class template (as opposed to a		// We define UniversalPrinter as a class template (as opposed to a
// function template), as we need to partially specialize it for		// function template), as we need to partially specialize it for
// reference types, which cannot be done with function templates.		// reference types, which cannot be done with function templates.
skipping to change at line 480		skipping to change at line 481
GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);		GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
inline void PrintTo(char16_t c, ::std::ostream* os) {		inline void PrintTo(char16_t c, ::std::ostream* os) {
PrintTo(ImplicitCast_<char32_t>(c), os);		PrintTo(ImplicitCast_<char32_t>(c), os);
}		}
#ifdef __cpp_char8_t		#ifdef __cpp_char8_t
inline void PrintTo(char8_t c, ::std::ostream* os) {		inline void PrintTo(char8_t c, ::std::ostream* os) {
PrintTo(ImplicitCast_<char32_t>(c), os);		PrintTo(ImplicitCast_<char32_t>(c), os);
}		}
#endif		#endif
		// gcc/clang __{u,}int128_t
		#if defined(__SIZEOF_INT128__)
		GTEST_API_ void PrintTo(__uint128_t v, ::std::ostream* os);
		GTEST_API_ void PrintTo(__int128_t v, ::std::ostream* os);
		#endif // __SIZEOF_INT128__
// Overloads for C strings.		// Overloads for C strings.
GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);		GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
inline void PrintTo(char* s, ::std::ostream* os) {		inline void PrintTo(char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const char*>(s), os);		PrintTo(ImplicitCast_<const char*>(s), os);
}		}
// signed/unsigned char is often used for representing binary data, so		// signed/unsigned char is often used for representing binary data, so
// we print pointers to it as void* to be safe.		// we print pointers to it as void* to be safe.
inline void PrintTo(const signed char* s, ::std::ostream* os) {		inline void PrintTo(const signed char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const void*>(s), os);		PrintTo(ImplicitCast_<const void*>(s), os);
skipping to change at line 546		skipping to change at line 553
template <typename T>		template <typename T>
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {		void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
UniversalPrint(a[0], os);		UniversalPrint(a[0], os);
for (size_t i = 1; i != count; i++) {		for (size_t i = 1; i != count; i++) {
*os << ", ";		*os << ", ";
UniversalPrint(a[i], os);		UniversalPrint(a[i], os);
}		}
}		}
// Overloads for ::std::string.		// Overloads for ::std::string.
GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);		GTEST_API_ void PrintStringTo(const ::std::string& s, ::std::ostream* os);
inline void PrintTo(const ::std::string& s, ::std::ostream* os) {		inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
PrintStringTo(s, os);		PrintStringTo(s, os);
}		}
// Overloads for ::std::u8string		// Overloads for ::std::u8string
#ifdef __cpp_char8_t		#ifdef __cpp_char8_t
GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);		GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {		inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
PrintU8StringTo(s, os);		PrintU8StringTo(s, os);
}		}
skipping to change at line 573		skipping to change at line 580
}		}
// Overloads for ::std::u32string		// Overloads for ::std::u32string
GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);		GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {		inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
PrintU32StringTo(s, os);		PrintU32StringTo(s, os);
}		}
// Overloads for ::std::wstring.		// Overloads for ::std::wstring.
#if GTEST_HAS_STD_WSTRING		#if GTEST_HAS_STD_WSTRING
GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);		GTEST_API_ void PrintWideStringTo(const ::std::wstring& s, ::std::ostream* os);
inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {		inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
PrintWideStringTo(s, os);		PrintWideStringTo(s, os);
}		}
#endif // GTEST_HAS_STD_WSTRING		#endif // GTEST_HAS_STD_WSTRING
#if GTEST_INTERNAL_HAS_STRING_VIEW		#if GTEST_INTERNAL_HAS_STRING_VIEW
// Overload for internal::StringView.		// Overload for internal::StringView.
inline void PrintTo(internal::StringView sp, ::std::ostream* os) {		inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
PrintTo(::std::string(sp), os);		PrintTo(::std::string(sp), os);
}		}
#endif // GTEST_INTERNAL_HAS_STRING_VIEW		#endif // GTEST_INTERNAL_HAS_STRING_VIEW
inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }		inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
		#if GTEST_HAS_RTTI
		inline void PrintTo(const std::type_info& info, std::ostream* os) {
		*os << internal::GetTypeName(info);
		}
		#endif // GTEST_HAS_RTTI
template <typename T>		template <typename T>
void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {		void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
UniversalPrinter<T&>::Print(ref.get(), os);		UniversalPrinter<T&>::Print(ref.get(), os);
}		}
inline const void* VoidifyPointer(const void* p) { return p; }		inline const void* VoidifyPointer(const void* p) { return p; }
inline const void* VoidifyPointer(volatile const void* p) {		inline const void* VoidifyPointer(volatile const void* p) {
return const_cast<const void*>(p);		return const_cast<const void*>(p);
}		}
skipping to change at line 745		skipping to change at line 758
*os << '(';		*os << '(';
if (!value) {		if (!value) {
*os << "nullopt";		*os << "nullopt";
} else {		} else {
UniversalPrint(*value, os);		UniversalPrint(*value, os);
}		}
*os << ')';		*os << ')';
}		}
};		};
		template <>
		class UniversalPrinter<decltype(Nullopt())> {
		public:
		static void Print(decltype(Nullopt()), ::std::ostream* os) {
		*os << "(nullopt)";
		}
		};
#endif // GTEST_INTERNAL_HAS_OPTIONAL		#endif // GTEST_INTERNAL_HAS_OPTIONAL
#if GTEST_INTERNAL_HAS_VARIANT		#if GTEST_INTERNAL_HAS_VARIANT
// Printer for std::variant / absl::variant		// Printer for std::variant / absl::variant
template <typename... T>		template <typename... T>
class UniversalPrinter<Variant<T...>> {		class UniversalPrinter<Variant<T...>> {
public:		public:
static void Print(const Variant<T...>& value, ::std::ostream* os) {		static void Print(const Variant<T...>& value, ::std::ostream* os) {
skipping to change at line 803		skipping to change at line 824
PrintRawArrayTo(begin, len, os);		PrintRawArrayTo(begin, len, os);
} else {		} else {
PrintRawArrayTo(begin, kChunkSize, os);		PrintRawArrayTo(begin, kChunkSize, os);
*os << ", ..., ";		*os << ", ..., ";
PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);		PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
}		}
*os << " }";		*os << " }";
}		}
}		}
// This overload prints a (const) char array compactly.		// This overload prints a (const) char array compactly.
GTEST_API_ void UniversalPrintArray(		GTEST_API_ void UniversalPrintArray(const char* begin, size_t len,
const char* begin, size_t len, ::std::ostream* os);		::std::ostream* os);
#ifdef __cpp_char8_t		#ifdef __cpp_char8_t
// This overload prints a (const) char8_t array compactly.		// This overload prints a (const) char8_t array compactly.
GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,		GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
::std::ostream* os);		::std::ostream* os);
#endif		#endif
// This overload prints a (const) char16_t array compactly.		// This overload prints a (const) char16_t array compactly.
GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,		GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
::std::ostream* os);		::std::ostream* os);
// This overload prints a (const) char32_t array compactly.		// This overload prints a (const) char32_t array compactly.
GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,		GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
::std::ostream* os);		::std::ostream* os);
// This overload prints a (const) wchar_t array compactly.		// This overload prints a (const) wchar_t array compactly.
GTEST_API_ void UniversalPrintArray(		GTEST_API_ void UniversalPrintArray(const wchar_t* begin, size_t len,
const wchar_t* begin, size_t len, ::std::ostream* os);		::std::ostream* os);
// Implements printing an array type T[N].		// Implements printing an array type T[N].
template <typename T, size_t N>		template <typename T, size_t N>
class UniversalPrinter<T[N]> {		class UniversalPrinter<T[N]> {
public:		public:
// Prints the given array, omitting some elements when there are too		// Prints the given array, omitting some elements when there are too
// many.		// many.
static void Print(const T (&a)[N], ::std::ostream* os) {		static void Print(const T (&a)[N], ::std::ostream* os) {
UniversalPrintArray(a, N, os);		UniversalPrintArray(a, N, os);
}		}
skipping to change at line 981		skipping to change at line 1002
// (const) char pointer, this prints both the pointer and the		// (const) char pointer, this prints both the pointer and the
// NUL-terminated string.		// NUL-terminated string.
template <typename T>		template <typename T>
void UniversalPrint(const T& value, ::std::ostream* os) {		void UniversalPrint(const T& value, ::std::ostream* os) {
// A workarond for the bug in VC++ 7.1 that prevents us from instantiating		// A workarond for the bug in VC++ 7.1 that prevents us from instantiating
// UniversalPrinter with T directly.		// UniversalPrinter with T directly.
typedef T T1;		typedef T T1;
UniversalPrinter<T1>::Print(value, os);		UniversalPrinter<T1>::Print(value, os);
}		}
typedef ::std::vector< ::std::string> Strings;		typedef ::std::vector<::std::string> Strings;
// Tersely prints the first N fields of a tuple to a string vector,		// Tersely prints the first N fields of a tuple to a string vector,
// one element for each field.		// one element for each field.
template <typename Tuple>		template <typename Tuple>
void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,		void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
Strings*) {}		Strings*) {}
template <typename Tuple, size_t I>		template <typename Tuple, size_t I>
void TersePrintPrefixToStrings(const Tuple& t,		void TersePrintPrefixToStrings(const Tuple& t,
std::integral_constant<size_t, I>,		std::integral_constant<size_t, I>,
Strings* strings) {		Strings* strings) {
TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),		TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
strings);		strings);
::std::stringstream ss;		::std::stringstream ss;
End of changes. 14 change blocks.
21 lines changed or deleted		42 lines changed or added

---