proxygen: testing::gtest_printers_test Namespace Reference

Classes
class	AllowsGenericStreaming

class	AllowsGenericStreamingAndImplicitConversionTemplate

class	AllowsGenericStreamingTemplate

struct	Big

struct	const_iterator

struct	Foo

struct	iterator

Functions
template<typename T >
string	Print (const T &value)

template<typename T >
string	PrintByRef (const T &value)

	TEST (PrintEnumTest, AnonymousEnum)

	TEST (PrintEnumTest, EnumWithoutPrinter)

	TEST (PrintEnumTest, EnumWithStreaming)

	TEST (PrintEnumTest, EnumWithPrintTo)

	TEST (PrintClassTest, BiggestIntConvertible)

	TEST (PrintCharTest, PlainChar)

	TEST (PrintCharTest, SignedChar)

	TEST (PrintCharTest, UnsignedChar)

	TEST (PrintBuiltInTypeTest, Bool)

	TEST (PrintBuiltInTypeTest, Wchar_t)

	TEST (PrintTypeSizeTest, Wchar_t)

	TEST (PrintBuiltInTypeTest, Integer)

	TEST (PrintBuiltInTypeTest, Size_t)

	TEST (PrintBuiltInTypeTest, FloatingPoints)

static string	PrintPointer (const void *p)

	TEST (PrintCStringTest, Const)

	TEST (PrintCStringTest, NonConst)

	TEST (PrintCStringTest, Null)

	TEST (PrintCStringTest, EscapesProperly)

	TEST (PrintWideCStringTest, Const)

	TEST (PrintWideCStringTest, NonConst)

	TEST (PrintWideCStringTest, Null)

	TEST (PrintWideCStringTest, EscapesProperly)

	TEST (PrintCharPointerTest, SignedChar)

	TEST (PrintCharPointerTest, ConstSignedChar)

	TEST (PrintCharPointerTest, UnsignedChar)

	TEST (PrintCharPointerTest, ConstUnsignedChar)

	TEST (PrintPointerToBuiltInTypeTest, Bool)

	TEST (PrintPointerToBuiltInTypeTest, Void)

	TEST (PrintPointerToBuiltInTypeTest, ConstVoid)

	TEST (PrintPointerToPointerTest, IntPointerPointer)

void	MyFunction (int)

	TEST (PrintPointerTest, NonMemberFunctionPointer)

template<typename StringType >
AssertionResult	HasPrefix (const StringType &str, const StringType &prefix)

	TEST (PrintPointerTest, MemberVariablePointer)

	TEST (PrintPointerTest, MemberFunctionPointer)

template<typename T , size_t N>
string	PrintArrayHelper (T(&a)[N])

	TEST (PrintArrayTest, OneDimensionalArray)

	TEST (PrintArrayTest, TwoDimensionalArray)

	TEST (PrintArrayTest, ConstArray)

	TEST (PrintArrayTest, CharArrayWithNoTerminatingNul)

	TEST (PrintArrayTest, ConstCharArrayWithTerminatingNul)

	TEST (PrintArrayTest, WCharArrayWithNoTerminatingNul)

	TEST (PrintArrayTest, WConstCharArrayWithTerminatingNul)

	TEST (PrintArrayTest, ObjectArray)

	TEST (PrintArrayTest, BigArray)

	TEST (PrintStringTest, StringInStdNamespace)

	TEST (PrintStringTest, StringAmbiguousHex)

template<typename Char , typename CharTraits >
std::basic_ostream< Char, CharTraits > &	operator<< (std::basic_ostream< Char, CharTraits > &os, const AllowsGenericStreaming &)

	TEST (PrintTypeWithGenericStreamingTest, NonTemplateType)

template<typename Char , typename CharTraits , typename T >
std::basic_ostream< Char, CharTraits > &	operator<< (std::basic_ostream< Char, CharTraits > &os, const AllowsGenericStreamingTemplate< T > &)

	TEST (PrintTypeWithGenericStreamingTest, TemplateType)

template<typename Char , typename CharTraits , typename T >
std::basic_ostream< Char, CharTraits > &	operator<< (std::basic_ostream< Char, CharTraits > &os, const AllowsGenericStreamingAndImplicitConversionTemplate< T > &)

	TEST (PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible)

	TEST (PrintStlContainerTest, EmptyDeque)

	TEST (PrintStlContainerTest, NonEmptyDeque)

	TEST (PrintStlContainerTest, List)

	TEST (PrintStlContainerTest, Map)

	TEST (PrintStlContainerTest, MultiMap)

	TEST (PrintStlContainerTest, Set)

	TEST (PrintStlContainerTest, MultiSet)

	TEST (PrintStlContainerTest, Pair)

	TEST (PrintStlContainerTest, Vector)

	TEST (PrintStlContainerTest, LongSequence)

	TEST (PrintStlContainerTest, NestedContainer)

	TEST (PrintStlContainerTest, OneDimensionalNativeArray)

	TEST (PrintStlContainerTest, TwoDimensionalNativeArray)

	TEST (PrintStlContainerTest, Iterator)

	TEST (PrintStlContainerTest, ConstIterator)

	TEST (PrintUnprintableTypeTest, InGlobalNamespace)

	TEST (PrintUnprintableTypeTest, InUserNamespace)

	TEST (PrintUnpritableTypeTest, BigObject)

	TEST (PrintStreamableTypeTest, InGlobalNamespace)

	TEST (PrintStreamableTypeTest, TemplateTypeInUserNamespace)

	TEST (PrintPrintableTypeTest, InUserNamespace)

	TEST (PrintPrintableTypeTest, PointerInUserNamespace)

	TEST (PrintPrintableTypeTest, TemplateInUserNamespace)

	TEST (PrintReferenceTest, PrintsAddressAndValue)

	TEST (PrintReferenceTest, HandlesFunctionPointer)

	TEST (PrintReferenceTest, HandlesMemberFunctionPointer)

	TEST (PrintReferenceTest, HandlesMemberVariablePointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForScalar)

	TEST (FormatForComparisonFailureMessageTest, WorksForNonCharPointer)

	TEST (FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForCharPointerVsStdString)

	TEST (FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray)

	TEST (FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer)

	TEST (FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCharArray)

	TEST (FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdString)

	TEST (PrintToStringTest, WorksForScalar)

	TEST (PrintToStringTest, WorksForPointerToConstChar)

	TEST (PrintToStringTest, WorksForPointerToNonConstChar)

	TEST (PrintToStringTest, EscapesForPointerToConstChar)

	TEST (PrintToStringTest, EscapesForPointerToNonConstChar)

	TEST (PrintToStringTest, WorksForArray)

	TEST (PrintToStringTest, WorksForCharArray)

	TEST (PrintToStringTest, WorksForCharArrayWithEmbeddedNul)

	TEST (UniversalTersePrintTest, WorksForNonReference)

	TEST (UniversalTersePrintTest, WorksForReference)

	TEST (UniversalTersePrintTest, WorksForCString)

	TEST (UniversalPrintTest, WorksForNonReference)

	TEST (UniversalPrintTest, WorksForReference)

	TEST (UniversalPrintTest, WorksForCString)

	TEST (UniversalPrintTest, WorksForCharArray)

static string	PrintPointer (const void *p)

static string	PrintPointer (const void *p)

Function Documentation

template<typename StringType >

AssertionResult testing::gtest_printers_test::HasPrefix	(	const StringType &	str,
		const StringType &	prefix
	)

Definition at line 542 of file gtest-printers_test.cc.

References testing::AssertionFailure(), and testing::AssertionSuccess().

Referenced by testing::gtest_printers_test::Big::Big(), testing::gtest_printers_test::Foo::MyVirtualMethod(), PrintPointer(), and TEST().

                                                                            {
   if (str.find(prefix, 0) == 0)
     return AssertionSuccess();
 
   const bool is_wide_string = sizeof(prefix[0]) > 1;
   const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
   return AssertionFailure()
       << begin_string_quote << prefix << "\" is not a prefix of "
       << begin_string_quote << str << "\"\n";
 }

void testing::gtest_printers_test::MyFunction ( int )

Definition at line 524 of file gtest-printers_test.cc.

Referenced by testing::gtest_printers_test::Big::Big(), PrintPointer(), TEST(), testing::gmock_more_actions_test::TEST(), and testing::gmock_more_actions_test::DeletionTester::~DeletionTester().

524 {}

template<typename Char , typename CharTraits >

std::basic_ostream< Char, CharTraits > & testing::gtest_printers_test::operator<<	(	std::basic_ostream< Char, CharTraits > &	os,
		const AllowsGenericStreaming &
	)

Definition at line 736 of file gtest-printers_test.cc.

                                      {
   return os << "AllowsGenericStreaming";
 }

template<typename Char , typename CharTraits , typename T >

std::basic_ostream< Char, CharTraits > & testing::gtest_printers_test::operator<<	(	std::basic_ostream< Char, CharTraits > &	os,
		const AllowsGenericStreamingTemplate< T > &
	)

Definition at line 753 of file gtest-printers_test.cc.

                                                 {
   return os << "AllowsGenericStreamingTemplate";
 }

template<typename Char , typename CharTraits , typename T >

std::basic_ostream< Char, CharTraits > & testing::gtest_printers_test::operator<<	(	std::basic_ostream< Char, CharTraits > &	os,
		const AllowsGenericStreamingAndImplicitConversionTemplate< T > &
	)

Definition at line 774 of file gtest-printers_test.cc.

                                                                      {
   return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
 }

template<typename T >

string testing::gtest_printers_test::Print ( const T & value )

Definition at line 235 of file gtest-printers_test.cc.

                              {
   ::std::stringstream ss;
   UniversalPrinter<T>::Print(value, &ss);
   return ss.str();
 }

template<typename T , size_t N>

string testing::gtest_printers_test::PrintArrayHelper ( T(&) a[N] )

Definition at line 595 of file gtest-printers_test.cc.

References a, and Print().

Referenced by testing::gtest_printers_test::Foo::MyVirtualMethod(), and TEST().

                                    {
   return Print(a);
 }

template<typename T >

string testing::gtest_printers_test::PrintByRef ( const T & value )

Definition at line 245 of file gtest-printers_test.cc.

References Print().

Referenced by testing::gtest_printers_test::Big::Big(), TEST(), and foo::StreamableTemplateInFoo< T >::value().

                                   {
   ::std::stringstream ss;
   UniversalPrinter<T&>::Print(value, &ss);
   return ss.str();
 }

static string testing::gtest_printers_test::PrintPointer ( const void * p )

static

Definition at line 382 of file gtest-printers_test.cc.

                                           {
   ::std::stringstream expected_result_stream;
   expected_result_stream << p;
   return expected_result_stream.str();
 }

static string testing::gtest_printers_test::PrintPointer ( const void * p )

static

Definition at line 382 of file gtest-printers_test.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), EXPECT_EQ, HasPrefix(), MyFunction(), prefix(), Print(), PrintPointer(), s, and TEST().

                                           {
   ::std::stringstream expected_result_stream;
   expected_result_stream << p;
   return expected_result_stream.str();
 }

static string testing::gtest_printers_test::PrintPointer ( const void * p )

static

Definition at line 382 of file gtest-printers_test.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), EXPECT_EQ, HasPrefix(), MyFunction(), prefix(), Print(), s, and TEST().

Referenced by testing::gtest_printers_test::Big::Big(), testing::gtest_printers_test::AllowsGenericStreamingAndImplicitConversionTemplate< T >::operator bool(), PrintPointer(), and TEST().

                                           {
   ::std::stringstream expected_result_stream;
   expected_result_stream << p;
   return expected_result_stream.str();
 }

testing::gtest_printers_test::TEST	(	PrintEnumTest	,
		AnonymousEnum
	)

Definition at line 253 of file gtest-printers_test.cc.

References EXPECT_EQ, kAE1, kAE2, and Print().

                                    {
   EXPECT_EQ("-1", Print(kAE1));
   EXPECT_EQ("1", Print(kAE2));
 }

testing::gtest_printers_test::TEST	(	PrintEnumTest	,
		EnumWithoutPrinter
	)

Definition at line 258 of file gtest-printers_test.cc.

References EXPECT_EQ, kEWP1, kEWP2, and Print().

                                         {
   EXPECT_EQ("-2", Print(kEWP1));
   EXPECT_EQ("42", Print(kEWP2));
 }

testing::gtest_printers_test::TEST	(	PrintEnumTest	,
		EnumWithStreaming
	)

Definition at line 263 of file gtest-printers_test.cc.

References EXPECT_EQ, kEWS1, and Print().

                                        {
   EXPECT_EQ("kEWS1", Print(kEWS1));
   EXPECT_EQ("invalid", Print(static_cast<EnumWithStreaming>(0)));
 }

testing::gtest_printers_test::TEST	(	PrintEnumTest	,
		EnumWithPrintTo
	)

Definition at line 268 of file gtest-printers_test.cc.

References EXPECT_EQ, kEWPT1, and Print().

                                      {
   EXPECT_EQ("kEWPT1", Print(kEWPT1));
   EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
 }

testing::gtest_printers_test::TEST	(	PrintClassTest	,
		BiggestIntConvertible
	)

Definition at line 275 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                             {
   EXPECT_EQ("42", Print(BiggestIntConvertible()));
 }

testing::gtest_printers_test::TEST	(	PrintCharTest	,
		PlainChar
	)

Definition at line 282 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                {
   EXPECT_EQ("'\\0'", Print('\0'));
   EXPECT_EQ("'\\'' (39, 0x27)", Print('\''));
   EXPECT_EQ("'\"' (34, 0x22)", Print('"'));
   EXPECT_EQ("'?' (63, 0x3F)", Print('?'));
   EXPECT_EQ("'\\\\' (92, 0x5C)", Print('\\'));
   EXPECT_EQ("'\\a' (7)", Print('\a'));
   EXPECT_EQ("'\\b' (8)", Print('\b'));
   EXPECT_EQ("'\\f' (12, 0xC)", Print('\f'));
   EXPECT_EQ("'\\n' (10, 0xA)", Print('\n'));
   EXPECT_EQ("'\\r' (13, 0xD)", Print('\r'));
   EXPECT_EQ("'\\t' (9)", Print('\t'));
   EXPECT_EQ("'\\v' (11, 0xB)", Print('\v'));
   EXPECT_EQ("'\\x7F' (127)", Print('\x7F'));
   EXPECT_EQ("'\\xFF' (255)", Print('\xFF'));
   EXPECT_EQ("' ' (32, 0x20)", Print(' '));
   EXPECT_EQ("'a' (97, 0x61)", Print('a'));
 }

testing::gtest_printers_test::TEST	(	PrintCharTest	,
		SignedChar
	)

Definition at line 302 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                 {
   EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));
   EXPECT_EQ("'\\xCE' (-50)",
             Print(static_cast<signed char>(-50)));
 }

testing::gtest_printers_test::TEST	(	PrintCharTest	,
		UnsignedChar
	)

Definition at line 309 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                   {
   EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));
   EXPECT_EQ("'b' (98, 0x62)",
             Print(static_cast<unsigned char>('b')));
 }

testing::gtest_printers_test::TEST	(	PrintBuiltInTypeTest	,
		Bool
	)

Definition at line 318 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                  {
   EXPECT_EQ("false", Print(false));
   EXPECT_EQ("true", Print(true));
 }

testing::gtest_printers_test::TEST	(	PrintBuiltInTypeTest	,
		Wchar_t
	)

Definition at line 324 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                     {
   EXPECT_EQ("L'\\0'", Print(L'\0'));
   EXPECT_EQ("L'\\'' (39, 0x27)", Print(L'\''));
   EXPECT_EQ("L'\"' (34, 0x22)", Print(L'"'));
   EXPECT_EQ("L'?' (63, 0x3F)", Print(L'?'));
   EXPECT_EQ("L'\\\\' (92, 0x5C)", Print(L'\\'));
   EXPECT_EQ("L'\\a' (7)", Print(L'\a'));
   EXPECT_EQ("L'\\b' (8)", Print(L'\b'));
   EXPECT_EQ("L'\\f' (12, 0xC)", Print(L'\f'));
   EXPECT_EQ("L'\\n' (10, 0xA)", Print(L'\n'));
   EXPECT_EQ("L'\\r' (13, 0xD)", Print(L'\r'));
   EXPECT_EQ("L'\\t' (9)", Print(L'\t'));
   EXPECT_EQ("L'\\v' (11, 0xB)", Print(L'\v'));
   EXPECT_EQ("L'\\x7F' (127)", Print(L'\x7F'));
   EXPECT_EQ("L'\\xFF' (255)", Print(L'\xFF'));
   EXPECT_EQ("L' ' (32, 0x20)", Print(L' '));
   EXPECT_EQ("L'a' (97, 0x61)", Print(L'a'));
   EXPECT_EQ("L'\\x576' (1398)", Print(static_cast<wchar_t>(0x576)));
   EXPECT_EQ("L'\\xC74D' (51021)", Print(static_cast<wchar_t>(0xC74D)));
 }

testing::gtest_printers_test::TEST	(	PrintTypeSizeTest	,
		Wchar_t
	)

Definition at line 346 of file gtest-printers_test.cc.

References EXPECT_LT.

                                  {
   EXPECT_LT(sizeof(wchar_t), sizeof(testing::internal::Int64));
 }

testing::gtest_printers_test::TEST	(	PrintBuiltInTypeTest	,
		Integer
	)

Definition at line 351 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                     {
   EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8
   EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8
   EXPECT_EQ("65535", Print(USHRT_MAX));  // uint16
   EXPECT_EQ("-32768", Print(SHRT_MIN));  // int16
   EXPECT_EQ("4294967295", Print(UINT_MAX));  // uint32
   EXPECT_EQ("-2147483648", Print(INT_MIN));  // int32
   EXPECT_EQ("18446744073709551615",
             Print(static_cast<testing::internal::UInt64>(-1)));  // uint64
   EXPECT_EQ("-9223372036854775808",
             Print(static_cast<testing::internal::Int64>(1) << 63));  // int64
 }

testing::gtest_printers_test::TEST	(	PrintBuiltInTypeTest	,
		Size_t
	)

Definition at line 365 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                    {
   EXPECT_EQ("1", Print(sizeof('a')));  // size_t.
 #if !GTEST_OS_WINDOWS
   // Windows has no ssize_t type.
   EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.
 #endif  // !GTEST_OS_WINDOWS
 }

testing::gtest_printers_test::TEST	(	PrintBuiltInTypeTest	,
		FloatingPoints
	)

Definition at line 374 of file gtest-printers_test.cc.

References EXPECT_EQ, f, and Print().

                                            {
   EXPECT_EQ("1.5", Print(1.5f));   // float
   EXPECT_EQ("-2.5", Print(-2.5));  // double
 }

testing::gtest_printers_test::TEST	(	PrintCStringTest	,
		Const
	)

Definition at line 391 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                               {
   const char* p = "World";
   EXPECT_EQ(PrintPointer(p) + " pointing to \"World\"", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintCStringTest	,
		NonConst
	)

Definition at line 397 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                  {
   char p[] = "Hi";
   EXPECT_EQ(PrintPointer(p) + " pointing to \"Hi\"",
             Print(static_cast<char*>(p)));
 }

testing::gtest_printers_test::TEST	(	PrintCStringTest	,
		Null
	)

Definition at line 404 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                              {
   const char* p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintCStringTest	,
		EscapesProperly
	)

Definition at line 410 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                         {
   const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
   EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"
             "\\n\\r\\t\\v\\x7F\\xFF a\"",
             Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintWideCStringTest	,
		Const
	)

Definition at line 426 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                   {
   const wchar_t* p = L"World";
   EXPECT_EQ(PrintPointer(p) + " pointing to L\"World\"", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintWideCStringTest	,
		NonConst
	)

Definition at line 432 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                      {
   wchar_t p[] = L"Hi";
   EXPECT_EQ(PrintPointer(p) + " pointing to L\"Hi\"",
             Print(static_cast<wchar_t*>(p)));
 }

testing::gtest_printers_test::TEST	(	PrintWideCStringTest	,
		Null
	)

Definition at line 439 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                  {
   const wchar_t* p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintWideCStringTest	,
		EscapesProperly
	)

Definition at line 445 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), PrintPointer(), and s.

                                             {
   const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',
                        '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};
   EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"
             "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
             Print(static_cast<const wchar_t*>(s)));
 }

testing::gtest_printers_test::TEST	(	PrintCharPointerTest	,
		SignedChar
	)

Definition at line 457 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                        {
   signed char* p = reinterpret_cast<signed char*>(0x1234);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintCharPointerTest	,
		ConstSignedChar
	)

Definition at line 465 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                             {
   signed char* p = reinterpret_cast<signed char*>(0x1234);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintCharPointerTest	,
		UnsignedChar
	)

Definition at line 473 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                          {
   unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintCharPointerTest	,
		ConstUnsignedChar
	)

Definition at line 481 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                               {
   const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerToBuiltInTypeTest	,
		Bool
	)

Definition at line 491 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                           {
   bool* p = reinterpret_cast<bool*>(0xABCD);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerToBuiltInTypeTest	,
		Void
	)

Definition at line 499 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                           {
   void* p = reinterpret_cast<void*>(0xABCD);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerToBuiltInTypeTest	,
		ConstVoid
	)

Definition at line 507 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                                {
   const void* p = reinterpret_cast<const void*>(0xABCD);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerToPointerTest	,
		IntPointerPointer
	)

Definition at line 515 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and PrintPointer().

                                                    {
   int** p = reinterpret_cast<int**>(0xABCD);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerTest	,
		NonMemberFunctionPointer
	)

Definition at line 526 of file gtest-printers_test.cc.

References EXPECT_EQ, MyFunction(), Print(), and PrintPointer().

                                                  {
   // We cannot directly cast &MyFunction to const void* because the
   // standard disallows casting between pointers to functions and
   // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
   // this limitation.
   EXPECT_EQ(
       PrintPointer(reinterpret_cast<const void*>(
           reinterpret_cast<internal::BiggestInt>(&MyFunction))),
       Print(&MyFunction));
   int (*p)(bool) = NULL;  // NOLINT
   EXPECT_EQ("NULL", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintPointerTest	,
		MemberVariablePointer
	)

Definition at line 567 of file gtest-printers_test.cc.

References EXPECT_TRUE, HasPrefix(), Print(), and value.

                                               {
   EXPECT_TRUE(HasPrefix(Print(&Foo::value),
                         Print(sizeof(&Foo::value)) + "-byte object "));
   int (Foo::*p) = NULL;  // NOLINT
   EXPECT_TRUE(HasPrefix(Print(p),
                         Print(sizeof(p)) + "-byte object "));
 }

testing::gtest_printers_test::TEST	(	PrintPointerTest	,
		MemberFunctionPointer
	)

Definition at line 579 of file gtest-printers_test.cc.

References EXPECT_TRUE, HasPrefix(), and Print().

                                               {
   EXPECT_TRUE(HasPrefix(Print(&Foo::MyMethod),
                         Print(sizeof(&Foo::MyMethod)) + "-byte object "));
   EXPECT_TRUE(
       HasPrefix(Print(&Foo::MyVirtualMethod),
                 Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));
   int (Foo::*p)(char) = NULL;  // NOLINT
   EXPECT_TRUE(HasPrefix(Print(p),
                         Print(sizeof(p)) + "-byte object "));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		OneDimensionalArray
	)

Definition at line 600 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                           {
   int a[5] = { 1, 2, 3, 4, 5 };
   EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		TwoDimensionalArray
	)

Definition at line 606 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                           {
   int a[2][5] = {
     { 1, 2, 3, 4, 5 },
     { 6, 7, 8, 9, 0 }
   };
   EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		ConstArray
	)

Definition at line 615 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                  {
   const bool a[1] = { false };
   EXPECT_EQ("{ false }", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		CharArrayWithNoTerminatingNul
	)

Definition at line 621 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                                     {
   // Array a contains '\0' in the middle and doesn't end with '\0'.
   char a[] = { 'H', '\0', 'i' };
   EXPECT_EQ("\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		ConstCharArrayWithTerminatingNul
	)

Definition at line 628 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                                        {
   const char a[] = "\0Hi";
   EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		WCharArrayWithNoTerminatingNul
	)

Definition at line 634 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                                      {
   // Array a contains '\0' in the middle and doesn't end with '\0'.
   const wchar_t a[] = { L'H', L'\0', L'i' };
   EXPECT_EQ("L\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		WConstCharArrayWithTerminatingNul
	)

Definition at line 641 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                                         {
   const wchar_t a[] = L"\0Hi";
   EXPECT_EQ("L\"\\0Hi\"", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		ObjectArray
	)

Definition at line 647 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and PrintArrayHelper().

                                   {
   string a[3] = { "Hi", "Hello", "Ni hao" };
   EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintArrayTest	,
		BigArray
	)

Definition at line 653 of file gtest-printers_test.cc.

References a, EXPECT_EQ, Print(), PrintArrayHelper(), s, string, and TEST().

                                {
   int a[100] = { 1, 2, 3 };
   EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
             PrintArrayHelper(a));
 }

testing::gtest_printers_test::TEST	(	PrintStringTest	,
		StringInStdNamespace
	)

Definition at line 672 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), s, and string.

                                             {
   const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
   const ::std::string str(s, sizeof(s));
   EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
             Print(str));
 }

testing::gtest_printers_test::TEST	(	PrintStringTest	,
		StringAmbiguousHex
	)

Definition at line 679 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), s, string, and TEST().

                                           {
   // "\x6BANANA" is ambiguous, it can be interpreted as starting with either of:
   // '\x6', '\x6B', or '\x6BA'.
 
   // a hex escaping sequence following by a decimal digit
   EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12" "3")));
   // a hex escaping sequence following by a hex digit (lower-case)
   EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6" "bananas")));
   // a hex escaping sequence following by a hex digit (upper-case)
   EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6" "BANANA")));
   // a hex escaping sequence following by a non-xdigit
   EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
 }

testing::gtest_printers_test::TEST	(	PrintTypeWithGenericStreamingTest	,
		NonTemplateType
	)

Definition at line 742 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and Print().

                                                          {
   AllowsGenericStreaming a;
   EXPECT_EQ("AllowsGenericStreaming", Print(a));
 }

testing::gtest_printers_test::TEST	(	PrintTypeWithGenericStreamingTest	,
		TemplateType
	)

Definition at line 759 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and Print().

                                                       {
   AllowsGenericStreamingTemplate<int> a;
   EXPECT_EQ("AllowsGenericStreamingTemplate", Print(a));
 }

testing::gtest_printers_test::TEST	(	PrintTypeWithGenericStreamingTest	,
		TypeImplicitlyConvertible
	)

Definition at line 780 of file gtest-printers_test.cc.

References a, EXPECT_EQ, Print(), and TEST().

                                                                    {
   AllowsGenericStreamingAndImplicitConversionTemplate<int> a;
   EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		EmptyDeque
	)

Definition at line 804 of file gtest-printers_test.cc.

References folly::empty(), EXPECT_EQ, and Print().

                                         {
   deque<char> empty;
   EXPECT_EQ("{}", Print(empty));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		NonEmptyDeque
	)

Definition at line 809 of file gtest-printers_test.cc.

References a, ASSERT_EQ, ASSERT_NE, EXPECT_EQ, EXPECT_TRUE, i, Print(), and TEST().

                                            {
   deque<int> non_empty;
   non_empty.push_back(1);
   non_empty.push_back(3);
   EXPECT_EQ("{ 1, 3 }", Print(non_empty));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		List
	)

Definition at line 877 of file gtest-printers_test.cc.

References a, EXPECT_EQ, Print(), and strings.

                                   {
   const string a[] = {
     "hello",
     "world"
   };
   const list<string> strings(a, a + 2);
   EXPECT_EQ("{ \"hello\", \"world\" }", Print(strings));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		Map
	)

Definition at line 886 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                  {
   map<int, bool> map1;
   map1[1] = true;
   map1[5] = false;
   map1[3] = true;
   EXPECT_EQ("{ (1, true), (3, true), (5, false) }", Print(map1));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		MultiMap
	)

Definition at line 894 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                       {
   multimap<bool, int> map1;
   // The make_pair template function would deduce the type as
   // pair<bool, int> here, and since the key part in a multimap has to
   // be constant, without a templated ctor in the pair class (as in
   // libCstd on Solaris), make_pair call would fail to compile as no
   // implicit conversion is found.  Thus explicit typename is used
   // here instead.
   map1.insert(pair<const bool, int>(true, 0));
   map1.insert(pair<const bool, int>(true, 1));
   map1.insert(pair<const bool, int>(false, 2));
   EXPECT_EQ("{ (false, 2), (true, 0), (true, 1) }", Print(map1));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		Set
	)

Definition at line 908 of file gtest-printers_test.cc.

References a, EXPECT_EQ, and Print().

                                  {
   const unsigned int a[] = { 3, 0, 5 };
   set<unsigned int> set1(a, a + 3);
   EXPECT_EQ("{ 0, 3, 5 }", Print(set1));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		MultiSet
	)

Definition at line 914 of file gtest-printers_test.cc.

References a, EXPECT_EQ, Print(), and TEST().

                                       {
   const int a[] = { 1, 1, 2, 5, 1 };
   multiset<int> set1(a, a + 5);
   EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		Pair
	)

Definition at line 931 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                   {
   pair<const bool, int> p(true, 5);
   EXPECT_EQ("(true, 5)", Print(p));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		Vector
	)

Definition at line 936 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and v.

                                     {
   vector<int> v;
   v.push_back(1);
   v.push_back(2);
   EXPECT_EQ("{ 1, 2 }", Print(v));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		LongSequence
	)

Definition at line 943 of file gtest-printers_test.cc.

References a, EXPECT_EQ, Print(), and v.

                                           {
   const int a[100] = { 1, 2, 3 };
   const vector<int> v(a, a + 100);
   EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
             "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }", Print(v));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		NestedContainer
	)

Definition at line 950 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and v.

                                              {
   const int a1[] = { 1, 2 };
   const int a2[] = { 3, 4, 5 };
   const list<int> l1(a1, a1 + 2);
   const list<int> l2(a2, a2 + 3);
 
   vector<list<int> > v;
   v.push_back(l1);
   v.push_back(l2);
   EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		OneDimensionalNativeArray
	)

Definition at line 962 of file gtest-printers_test.cc.

References a, b, EXPECT_EQ, and Print().

                                                        {
   const int a[3] = { 1, 2, 3 };
   NativeArray<int> b(a, 3, RelationToSourceReference());
   EXPECT_EQ("{ 1, 2, 3 }", Print(b));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		TwoDimensionalNativeArray
	)

Definition at line 968 of file gtest-printers_test.cc.

References a, b, EXPECT_EQ, and Print().

                                                        {
   const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
   NativeArray<int[3]> b(a, 2, RelationToSourceReference());
   EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		Iterator
	)

Definition at line 980 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                       {
   iterator it = {};
   EXPECT_EQ("1-byte object <00>", Print(it));
 }

testing::gtest_printers_test::TEST	(	PrintStlContainerTest	,
		ConstIterator
	)

Definition at line 991 of file gtest-printers_test.cc.

References EXPECT_EQ, std::tr1::make_tuple(), Print(), PrintPointer(), and TEST().

                                            {
   const_iterator it = {};
   EXPECT_EQ("1-byte object <00>", Print(it));
 }

testing::gtest_printers_test::TEST	(	PrintUnprintableTypeTest	,
		InGlobalNamespace
	)

Definition at line 1117 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                                   {
   EXPECT_EQ("1-byte object <00>",
             Print(UnprintableTemplateInGlobal<char>()));
 }

testing::gtest_printers_test::TEST	(	PrintUnprintableTypeTest	,
		InUserNamespace
	)

Definition at line 1123 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                                 {
   EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
             Print(::foo::UnprintableInFoo()));
 }

testing::gtest_printers_test::TEST	(	PrintUnpritableTypeTest	,
		BigObject
	)

Definition at line 1135 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                          {
   EXPECT_EQ("257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
             "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
             Print(Big()));
 }

testing::gtest_printers_test::TEST	(	PrintStreamableTypeTest	,
		InGlobalNamespace
	)

Definition at line 1149 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and x.

                                                  {
   StreamableInGlobal x;
   EXPECT_EQ("StreamableInGlobal", Print(x));
   EXPECT_EQ("StreamableInGlobal*", Print(&x));
 }

testing::gtest_printers_test::TEST	(	PrintStreamableTypeTest	,
		TemplateTypeInUserNamespace
	)

Definition at line 1156 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                                            {
   EXPECT_EQ("StreamableTemplateInFoo: 0",
             Print(::foo::StreamableTemplateInFoo<int>()));
 }

testing::gtest_printers_test::TEST	(	PrintPrintableTypeTest	,
		InUserNamespace
	)

Definition at line 1162 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                               {
   EXPECT_EQ("PrintableViaPrintTo: 0",
             Print(::foo::PrintableViaPrintTo()));
 }

testing::gtest_printers_test::TEST	(	PrintPrintableTypeTest	,
		PointerInUserNamespace
	)

Definition at line 1169 of file gtest-printers_test.cc.

References EXPECT_EQ, Print(), and x.

                                                      {
   ::foo::PointerPrintable x;
   EXPECT_EQ("PointerPrintable*", Print(&x));
 }

testing::gtest_printers_test::TEST	(	PrintPrintableTypeTest	,
		TemplateInUserNamespace
	)

Definition at line 1175 of file gtest-printers_test.cc.

References EXPECT_EQ, and Print().

                                                       {
   EXPECT_EQ("PrintableViaPrintToTemplate: 5",
             Print(::foo::PrintableViaPrintToTemplate<int>(5)));
 }

testing::gtest_printers_test::TEST	(	PrintReferenceTest	,
		PrintsAddressAndValue
	)

Definition at line 1182 of file gtest-printers_test.cc.

References a, EXPECT_EQ, PrintByRef(), PrintPointer(), and x.

                                                 {
   int n = 5;
   EXPECT_EQ("@" + PrintPointer(&n) + " 5", PrintByRef(n));
 
   int a[2][3] = {
     { 0, 1, 2 },
     { 3, 4, 5 }
   };
   EXPECT_EQ("@" + PrintPointer(a) + " { { 0, 1, 2 }, { 3, 4, 5 } }",
             PrintByRef(a));
 
   const ::foo::UnprintableInFoo x;
   EXPECT_EQ("@" + PrintPointer(&x) + " 16-byte object "
             "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
             PrintByRef(x));
 }

testing::gtest_printers_test::TEST	(	PrintReferenceTest	,
		HandlesFunctionPointer
	)

Definition at line 1201 of file gtest-printers_test.cc.

References EXPECT_EQ, MyFunction(), PrintByRef(), and PrintPointer().

                                                  {
   void (*fp)(int n) = &MyFunction;
   const string fp_pointer_string =
       PrintPointer(reinterpret_cast<const void*>(&fp));
   // We cannot directly cast &MyFunction to const void* because the
   // standard disallows casting between pointers to functions and
   // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
   // this limitation.
   const string fp_string = PrintPointer(reinterpret_cast<const void*>(
       reinterpret_cast<internal::BiggestInt>(fp)));
   EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
             PrintByRef(fp));
 }

testing::gtest_printers_test::TEST	(	PrintReferenceTest	,
		HandlesMemberFunctionPointer
	)

Definition at line 1217 of file gtest-printers_test.cc.

References ch, EXPECT_TRUE, HasPrefix(), Print(), PrintByRef(), and PrintPointer().

                                                        {
   int (Foo::*p)(char ch) = &Foo::MyMethod;
   EXPECT_TRUE(HasPrefix(
       PrintByRef(p),
       "@" + PrintPointer(reinterpret_cast<const void*>(&p)) + " " +
           Print(sizeof(p)) + "-byte object "));
 
   char (Foo::*p2)(int n) = &Foo::MyVirtualMethod;
   EXPECT_TRUE(HasPrefix(
       PrintByRef(p2),
       "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) + " " +
           Print(sizeof(p2)) + "-byte object "));
 }

testing::gtest_printers_test::TEST	(	PrintReferenceTest	,
		HandlesMemberVariablePointer
	)

Definition at line 1233 of file gtest-printers_test.cc.

References EXPECT_TRUE, HasPrefix(), Print(), PrintByRef(), PrintPointer(), and value.

                                                        {
   int (Foo::*p) = &Foo::value;  // NOLINT
   EXPECT_TRUE(HasPrefix(
       PrintByRef(p),
       "@" + PrintPointer(&p) + " " + Print(sizeof(p)) + "-byte object "));
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForScalar
	)

Definition at line 1245 of file gtest-printers_test.cc.

References EXPECT_STREQ, and testing::internal::FormatForComparisonFailureMessage().

                                                             {
   EXPECT_STREQ("123",
                FormatForComparisonFailureMessage(123, 124).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForNonCharPointer
	)

Definition at line 1251 of file gtest-printers_test.cc.

References EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), and PrintPointer().

                                                                     {
   int n = 0;
   EXPECT_EQ(PrintPointer(&n),
             FormatForComparisonFailureMessage(&n, &n).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		FormatsNonCharArrayAsPointer
	)

Definition at line 1258 of file gtest-printers_test.cc.

References EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), and PrintPointer().

                                                                           {
   // In expression 'array == x', 'array' is compared by pointer.
   // Therefore we want to print an array operand as a pointer.
   int n[] = { 1, 2, 3 };
   EXPECT_EQ(PrintPointer(n),
             FormatForComparisonFailureMessage(n, n).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForCharPointerVsPointer
	)

Definition at line 1271 of file gtest-printers_test.cc.

References ch, EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), PrintPointer(), and s.

                                                                           {
   // In expression 'p == x', where 'p' and 'x' are (const or not) char
   // pointers, the operands are compared by pointer.  Therefore we
   // want to print 'p' as a pointer instead of a C string (we don't
   // even know if it's supposed to point to a valid C string).
 
   // const char*
   const char* s = "hello";
   EXPECT_EQ(PrintPointer(s),
             FormatForComparisonFailureMessage(s, s).c_str());
 
   // char*
   char ch = 'a';
   EXPECT_EQ(PrintPointer(&ch),
             FormatForComparisonFailureMessage(&ch, &ch).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForWCharPointerVsPointer
	)

Definition at line 1289 of file gtest-printers_test.cc.

References ch, EXPECT_EQ, EXPECT_STREQ, testing::internal::FormatForComparisonFailureMessage(), PrintPointer(), s, and TEST().

                                                                            {
   // In expression 'p == x', where 'p' and 'x' are (const or not) char
   // pointers, the operands are compared by pointer.  Therefore we
   // want to print 'p' as a pointer instead of a wide C string (we don't
   // even know if it's supposed to point to a valid wide C string).
 
   // const wchar_t*
   const wchar_t* s = L"hello";
   EXPECT_EQ(PrintPointer(s),
             FormatForComparisonFailureMessage(s, s).c_str());
 
   // wchar_t*
   wchar_t ch = L'a';
   EXPECT_EQ(PrintPointer(&ch),
             FormatForComparisonFailureMessage(&ch, &ch).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForCharPointerVsStdString
	)

Definition at line 1325 of file gtest-printers_test.cc.

References EXPECT_STREQ, testing::internal::FormatForComparisonFailureMessage(), s, string, and TEST().

                                                                             {
   const char* s = "hello \"world";
   EXPECT_STREQ("\"hello \\\"world\"",  // The string content should be escaped.
                FormatForComparisonFailureMessage(s, ::std::string()).c_str());
 
   // char*
   char str[] = "hi\1";
   char* p = str;
   EXPECT_STREQ("\"hi\\x1\"",  // The string content should be escaped.
                FormatForComparisonFailureMessage(p, ::std::string()).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForCharArrayVsPointer
	)

Definition at line 1372 of file gtest-printers_test.cc.

References EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), and PrintPointer().

                                                                         {
   char str[] = "hi \"world\"";
   char* p = NULL;
   EXPECT_EQ(PrintPointer(str),
             FormatForComparisonFailureMessage(str, p).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForCharArrayVsCharArray
	)

Definition at line 1380 of file gtest-printers_test.cc.

References EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), and PrintPointer().

                                                                           {
   const char str[] = "hi \"world\"";
   EXPECT_EQ(PrintPointer(str),
             FormatForComparisonFailureMessage(str, str).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForWCharArrayVsPointer
	)

Definition at line 1387 of file gtest-printers_test.cc.

References EXPECT_EQ, testing::internal::FormatForComparisonFailureMessage(), and PrintPointer().

                                                                          {
   wchar_t str[] = L"hi \"world\"";
   wchar_t* p = NULL;
   EXPECT_EQ(PrintPointer(str),
             FormatForComparisonFailureMessage(str, p).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForWCharArrayVsWCharArray
	)

Definition at line 1395 of file gtest-printers_test.cc.

References EXPECT_EQ, EXPECT_STREQ, testing::internal::FormatForComparisonFailureMessage(), PrintPointer(), and TEST().

                                                                             {
   const wchar_t str[] = L"hi \"world\"";
   EXPECT_EQ(PrintPointer(str),
             FormatForComparisonFailureMessage(str, str).c_str());
 }

testing::gtest_printers_test::TEST	(	FormatForComparisonFailureMessageTest	,
		WorksForCharArrayVsStdString
	)

Definition at line 1415 of file gtest-printers_test.cc.

References EXPECT_STREQ, testing::internal::FormatForComparisonFailureMessage(), string, and TEST().

                                                                           {
   const char str[] = "hi \"world\"";
   EXPECT_STREQ("\"hi \\\"world\\\"\"",  // The content should be escaped.
                FormatForComparisonFailureMessage(str, ::std::string()).c_str());
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForScalar
	)

Definition at line 1448 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_.

                                         {
   EXPECT_PRINT_TO_STRING_(123, "123");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForPointerToConstChar
	)

Definition at line 1452 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_.

                                                     {
   const char* p = "hello";
   EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForPointerToNonConstChar
	)

Definition at line 1457 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_, and s.

                                                        {
   char s[] = "hello";
   char* p = s;
   EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		EscapesForPointerToConstChar
	)

Definition at line 1463 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_.

                                                       {
   const char* p = "hello\n";
   EXPECT_PRINT_TO_STRING_(p, "\"hello\\n\"");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		EscapesForPointerToNonConstChar
	)

Definition at line 1468 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_, and s.

                                                          {
   char s[] = "hello\1";
   char* p = s;
   EXPECT_PRINT_TO_STRING_(p, "\"hello\\x1\"");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForArray
	)

Definition at line 1474 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_.

                                        {
   int n[3] = { 1, 2, 3 };
   EXPECT_PRINT_TO_STRING_(n, "{ 1, 2, 3 }");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForCharArray
	)

Definition at line 1479 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_, and s.

                                            {
   char s[] = "hello";
   EXPECT_PRINT_TO_STRING_(s, "\"hello\"");
 }

testing::gtest_printers_test::TEST	(	PrintToStringTest	,
		WorksForCharArrayWithEmbeddedNul
	)

Definition at line 1484 of file gtest-printers_test.cc.

References EXPECT_PRINT_TO_STRING_.

                                                           {
   const char str_with_nul[] = "hello\0 world";
   EXPECT_PRINT_TO_STRING_(str_with_nul, "\"hello\\0 world\"");
 
   char mutable_str_with_nul[] = "hello\0 world";
   EXPECT_PRINT_TO_STRING_(mutable_str_with_nul, "\"hello\\0 world\"");
 }

testing::gtest_printers_test::TEST	(	UniversalTersePrintTest	,
		WorksForNonReference
	)

Definition at line 1494 of file gtest-printers_test.cc.

References EXPECT_EQ, and testing::internal::UniversalTersePrint().

                                                     {
   ::std::stringstream ss;
   UniversalTersePrint(123, &ss);
   EXPECT_EQ("123", ss.str());
 }

testing::gtest_printers_test::TEST	(	UniversalTersePrintTest	,
		WorksForReference
	)

Definition at line 1500 of file gtest-printers_test.cc.

References EXPECT_EQ, and testing::internal::UniversalTersePrint().

                                                  {
   const int& n = 123;
   ::std::stringstream ss;
   UniversalTersePrint(n, &ss);
   EXPECT_EQ("123", ss.str());
 }

testing::gtest_printers_test::TEST	(	UniversalTersePrintTest	,
		WorksForCString
	)

Definition at line 1507 of file gtest-printers_test.cc.

References EXPECT_EQ, and testing::internal::UniversalTersePrint().

                                                {
   const char* s1 = "abc";
   ::std::stringstream ss1;
   UniversalTersePrint(s1, &ss1);
   EXPECT_EQ("\"abc\"", ss1.str());
 
   char* s2 = const_cast<char*>(s1);
   ::std::stringstream ss2;
   UniversalTersePrint(s2, &ss2);
   EXPECT_EQ("\"abc\"", ss2.str());
 
   const char* s3 = NULL;
   ::std::stringstream ss3;
   UniversalTersePrint(s3, &ss3);
   EXPECT_EQ("NULL", ss3.str());
 }

testing::gtest_printers_test::TEST	(	UniversalPrintTest	,
		WorksForNonReference
	)

Definition at line 1524 of file gtest-printers_test.cc.

References EXPECT_EQ, and testing::internal::UniversalPrint().

                                                {
   ::std::stringstream ss;
   UniversalPrint(123, &ss);
   EXPECT_EQ("123", ss.str());
 }

testing::gtest_printers_test::TEST	(	UniversalPrintTest	,
		WorksForReference
	)

Definition at line 1530 of file gtest-printers_test.cc.

References EXPECT_EQ, and testing::internal::UniversalPrint().

                                             {
   const int& n = 123;
   ::std::stringstream ss;
   UniversalPrint(n, &ss);
   EXPECT_EQ("123", ss.str());
 }

testing::gtest_printers_test::TEST	(	UniversalPrintTest	,
		WorksForCString
	)

Definition at line 1537 of file gtest-printers_test.cc.

References EXPECT_EQ, PrintPointer(), and testing::internal::UniversalPrint().

                                           {
   const char* s1 = "abc";
   ::std::stringstream ss1;
   UniversalPrint(s1, &ss1);
   EXPECT_EQ(PrintPointer(s1) + " pointing to \"abc\"", string(ss1.str()));
 
   char* s2 = const_cast<char*>(s1);
   ::std::stringstream ss2;
   UniversalPrint(s2, &ss2);
   EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", string(ss2.str()));
 
   const char* s3 = NULL;
   ::std::stringstream ss3;
   UniversalPrint(s3, &ss3);
   EXPECT_EQ("NULL", ss3.str());
 }

testing::gtest_printers_test::TEST	(	UniversalPrintTest	,
		WorksForCharArray
	)

Definition at line 1554 of file gtest-printers_test.cc.

References ASSERT_EQ, EXPECT_EQ, std::tr1::make_tuple(), and testing::internal::UniversalPrint().

Referenced by testing::gtest_printers_test::Big::Big(), testing::gtest_printers_test::Foo::MyVirtualMethod(), testing::gtest_printers_test::AllowsGenericStreamingAndImplicitConversionTemplate< T >::operator bool(), PrintPointer(), TEST(), and foo::StreamableTemplateInFoo< T >::value().

                                             {
   const char str[] = "\"Line\0 1\"\nLine 2";
   ::std::stringstream ss1;
   UniversalPrint(str, &ss1);
   EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss1.str());
 
   const char mutable_str[] = "\"Line\0 1\"\nLine 2";
   ::std::stringstream ss2;
   UniversalPrint(mutable_str, &ss2);
   EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss2.str());
 }

Classes

Functions

Function Documentation