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 >
std::string	Print (const T &value)
template<typename T >
std::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 (PrintCharTest, Char16)
	TEST (PrintCharTest, Char32)
	TEST (PrintBuiltInTypeTest, Bool)
	TEST (PrintBuiltInTypeTest, Wchar_t)
	TEST (PrintTypeSizeTest, Wchar_t)
	TEST (PrintBuiltInTypeTest, Integer)
	TEST (PrintBuiltInTypeTest, Size_t)
	TEST (PrintBuiltInTypeTest, FloatingPoints)
	TEST (PrintCStringTest, Const)
	TEST (PrintCStringTest, NonConst)
	TEST (PrintCStringTest, Null)
	TEST (PrintCStringTest, EscapesProperly)
	TEST (PrintU16StringTest, Const)
	TEST (PrintU16StringTest, NonConst)
	TEST (PrintU16StringTest, Null)
	TEST (PrintU16StringTest, EscapesProperly)
	TEST (PrintU32StringTest, Const)
	TEST (PrintU32StringTest, NonConst)
	TEST (PrintU32StringTest, Null)
	TEST (PrintU32StringTest, 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>
std::string	PrintArrayHelper (T(&a)[N])
	TEST (PrintArrayTest, OneDimensionalArray)
	TEST (PrintArrayTest, TwoDimensionalArray)
	TEST (PrintArrayTest, ConstArray)
	TEST (PrintArrayTest, CharArrayWithNoTerminatingNul)
	TEST (PrintArrayTest, CharArrayWithTerminatingNul)
	TEST (PrintArrayTest, Char16ArrayWithNoTerminatingNul)
	TEST (PrintArrayTest, Char16ArrayWithTerminatingNul)
	TEST (PrintArrayTest, Char32ArrayWithNoTerminatingNul)
	TEST (PrintArrayTest, Char32ArrayWithTerminatingNul)
	TEST (PrintArrayTest, WCharArrayWithNoTerminatingNul)
	TEST (PrintArrayTest, WCharArrayWithTerminatingNul)
	TEST (PrintArrayTest, ObjectArray)
	TEST (PrintArrayTest, BigArray)
	TEST (PrintStringTest, StringInStdNamespace)
	TEST (PrintStringTest, StringAmbiguousHex)
	TEST (PrintStringTest, U16String)
	TEST (PrintStringTest, U32String)
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, OneElementHashMap)
	TEST (PrintStlContainerTest, HashMultiMap)
	TEST (PrintStlContainerTest, HashSet)
	TEST (PrintStlContainerTest, HashMultiSet)
	TEST (PrintStlContainerTest, List)
	TEST (PrintStlContainerTest, Map)
	TEST (PrintStlContainerTest, MultiMap)
	TEST (PrintStlContainerTest, Set)
	TEST (PrintStlContainerTest, MultiSet)
	TEST (PrintStlContainerTest, SinglyLinkedList)
	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 (PrintStdTupleTest, VariousSizes)
	TEST (PrintStdTupleTest, NestedTuple)
	TEST (PrintNullptrT, Basic)
	TEST (PrintReferenceWrapper, Printable)
	TEST (PrintReferenceWrapper, Unprintable)
	TEST (PrintUnprintableTypeTest, InGlobalNamespace)
	TEST (PrintUnprintableTypeTest, InUserNamespace)
	TEST (PrintUnpritableTypeTest, BigObject)
	TEST (PrintStreamableTypeTest, InGlobalNamespace)
	TEST (PrintStreamableTypeTest, TemplateTypeInUserNamespace)
	TEST (PrintStreamableTypeTest, TypeInUserNamespaceWithTemplatedStreamOperator)
	TEST (PrintStreamableTypeTest, SubclassUsesSuperclassStreamOperator)
	TEST (PrintStreamableTypeTest, PathLikeInUserNamespace)
	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 (PrintToStringTest, ContainsNonLatin)
	TEST (IsValidUTF8Test, IllFormedUTF8)
	TEST (UniversalTersePrintTest, WorksForNonReference)
	TEST (UniversalTersePrintTest, WorksForReference)
	TEST (UniversalTersePrintTest, WorksForCString)
	TEST (UniversalPrintTest, WorksForNonReference)
	TEST (UniversalPrintTest, WorksForReference)
	TEST (UniversalPrintTest, WorksForPairWithConst)
	TEST (UniversalPrintTest, WorksForCString)
	TEST (UniversalPrintTest, WorksForCharArray)
	TEST (UniversalPrintTest, IncompleteType)
	TEST (UniversalPrintTest, SmartPointers)
	TEST (UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple)
	TEST (UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple)
	TEST (UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple)
	TEST (UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely)

Function Documentation

HasPrefix()

template<typename StringType >

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

Definition at line 707 of file googletest-printers-test.cc.

                                                                           {
  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";
}

MyFunction()

void testing::gtest_printers_test::MyFunction

(

int

)

Definition at line 689 of file googletest-printers-test.cc.

{}

operator<<() [1/3]

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 929 of file googletest-printers-test.cc.

                                     {
  return os << "AllowsGenericStreaming";
}

operator<<() [2/3]

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 967 of file googletest-printers-test.cc.

                                                                     {
  return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
}

operator<<() [3/3]

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 950 of file googletest-printers-test.cc.

                                                {
  return os << "AllowsGenericStreamingTemplate";
}

Print()

template<typename T >

std::string testing::gtest_printers_test::Print

(

const T &

value

)

Definition at line 284 of file googletest-printers-test.cc.

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

PrintArrayHelper()

template<typename T , size_t N>

std::string testing::gtest_printers_test::PrintArrayHelper

(

T(&)

a[N]

)

Definition at line 760 of file googletest-printers-test.cc.

                                      {
  return Print(a);
}

PrintByRef()

template<typename T >

std::string testing::gtest_printers_test::PrintByRef

(

const T &

value

)

Definition at line 294 of file googletest-printers-test.cc.

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

TEST() [1/138]

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

Definition at line 1418 of file googletest-printers-test.cc.

                                                                          {
  // 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());
}

TEST() [2/138]

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

Definition at line 1510 of file googletest-printers-test.cc.

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

TEST() [3/138]

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

Definition at line 1502 of file googletest-printers-test.cc.

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

TEST() [4/138]

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

Definition at line 1535 of file googletest-printers-test.cc.

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

TEST() [5/138]

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

Definition at line 1431 of file googletest-printers-test.cc.

                                                                          {
  // 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());
}

TEST() [6/138]

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

Definition at line 1470 of file googletest-printers-test.cc.

                                                                            {
  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());
}

TEST() [7/138]

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

Definition at line 1411 of file googletest-printers-test.cc.

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

TEST() [8/138]

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

Definition at line 1405 of file googletest-printers-test.cc.

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

TEST() [9/138]

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

Definition at line 1517 of file googletest-printers-test.cc.

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

TEST() [10/138]

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

Definition at line 1525 of file googletest-printers-test.cc.

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

TEST() [11/138]

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

Definition at line 1449 of file googletest-printers-test.cc.

                                                                           {
  // 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());
}

TEST() [12/138]

testing::gtest_printers_test::TEST	(	IsValidUTF8Test	,
		IllFormedUTF8
	)

Definition at line 1615 of file googletest-printers-test.cc.

                                     {
  // The following test strings are ill-formed UTF-8 and are printed
  // as hex only (or ASCII, in case of ASCII bytes) because IsValidUTF8() is
  // expected to fail, thus output does not contain "As Text:".
 
  static const char *const kTestdata[][2] = {
    // 2-byte lead byte followed by a single-byte character.
    {"\xC3\x74", "\"\\xC3t\""},
    // Valid 2-byte character followed by an orphan trail byte.
    {"\xC3\x84\xA4", "\"\\xC3\\x84\\xA4\""},
    // Lead byte without trail byte.
    {"abc\xC3", "\"abc\\xC3\""},
    // 3-byte lead byte, single-byte character, orphan trail byte.
    {"x\xE2\x70\x94", "\"x\\xE2p\\x94\""},
    // Truncated 3-byte character.
    {"\xE2\x80", "\"\\xE2\\x80\""},
    // Truncated 3-byte character followed by valid 2-byte char.
    {"\xE2\x80\xC3\x84", "\"\\xE2\\x80\\xC3\\x84\""},
    // Truncated 3-byte character followed by a single-byte character.
    {"\xE2\x80\x7A", "\"\\xE2\\x80z\""},
    // 3-byte lead byte followed by valid 3-byte character.
    {"\xE2\xE2\x80\x94", "\"\\xE2\\xE2\\x80\\x94\""},
    // 4-byte lead byte followed by valid 3-byte character.
    {"\xF0\xE2\x80\x94", "\"\\xF0\\xE2\\x80\\x94\""},
    // Truncated 4-byte character.
    {"\xF0\xE2\x80", "\"\\xF0\\xE2\\x80\""},
     // Invalid UTF-8 byte sequences embedded in other chars.
    {"abc\xE2\x80\x94\xC3\x74xyc", "\"abc\\xE2\\x80\\x94\\xC3txyc\""},
    {"abc\xC3\x84\xE2\x80\xC3\x84xyz",
     "\"abc\\xC3\\x84\\xE2\\x80\\xC3\\x84xyz\""},
    // Non-shortest UTF-8 byte sequences are also ill-formed.
    // The classics: xC0, xC1 lead byte.
    {"\xC0\x80", "\"\\xC0\\x80\""},
    {"\xC1\x81", "\"\\xC1\\x81\""},
    // Non-shortest sequences.
    {"\xE0\x80\x80", "\"\\xE0\\x80\\x80\""},
    {"\xf0\x80\x80\x80", "\"\\xF0\\x80\\x80\\x80\""},
    // Last valid code point before surrogate range, should be printed as text,
    // too.
    {"\xED\x9F\xBF", "\"\\xED\\x9F\\xBF\"\n    As Text: \"퟿\""},
    // Start of surrogate lead. Surrogates are not printed as text.
    {"\xED\xA0\x80", "\"\\xED\\xA0\\x80\""},
    // Last non-private surrogate lead.
    {"\xED\xAD\xBF", "\"\\xED\\xAD\\xBF\""},
    // First private-use surrogate lead.
    {"\xED\xAE\x80", "\"\\xED\\xAE\\x80\""},
    // Last private-use surrogate lead.
    {"\xED\xAF\xBF", "\"\\xED\\xAF\\xBF\""},
    // Mid-point of surrogate trail.
    {"\xED\xB3\xBF", "\"\\xED\\xB3\\xBF\""},
    // First valid code point after surrogate range, should be printed as text,
    // too.
    {"\xEE\x80\x80", "\"\\xEE\\x80\\x80\"\n    As Text: \"\""}
  };
 
  for (int i = 0; i < int(sizeof(kTestdata)/sizeof(kTestdata[0])); ++i) {
    EXPECT_PRINT_TO_STRING_(kTestdata[i][0], kTestdata[i][1]);
  }
}

TEST() [13/138]

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

Definition at line 863 of file googletest-printers-test.cc.

                               {
  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));
}

TEST() [14/138]

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

Definition at line 816 of file googletest-printers-test.cc.

                                                      {
  // Array a contains '\0' in the middle and doesn't end with '\0'.
  const char16_t a[] = {u'こ', u'\0', u'ん', u'に', u'ち', u'は'};
  EXPECT_EQ("u\"\\x3053\\0\\x3093\\x306B\\x3061\\x306F\" (no terminating NUL)",
            PrintArrayHelper(a));
}

TEST() [15/138]

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

Definition at line 824 of file googletest-printers-test.cc.

                                                    {
  const char16_t a[] = u"\0こんにちは";
  EXPECT_EQ("u\"\\0\\x3053\\x3093\\x306B\\x3061\\x306F\"", PrintArrayHelper(a));
}

TEST() [16/138]

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

Definition at line 830 of file googletest-printers-test.cc.

                                                      {
  // Array a contains '\0' in the middle and doesn't end with '\0'.
  const char32_t a[] = {U'👋', U'\0', U'🌌'};
  EXPECT_EQ("U\"\\x1F44B\\0\\x1F30C\" (no terminating NUL)",
            PrintArrayHelper(a));
}

TEST() [17/138]

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

Definition at line 838 of file googletest-printers-test.cc.

                                                    {
  const char32_t a[] = U"\0👋🌌";
  EXPECT_EQ("U\"\\0\\x1F44B\\x1F30C\"", PrintArrayHelper(a));
}

TEST() [18/138]

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

Definition at line 786 of file googletest-printers-test.cc.

                                                    {
  // 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));
}

TEST() [19/138]

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

Definition at line 793 of file googletest-printers-test.cc.

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

TEST() [20/138]

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

Definition at line 780 of file googletest-printers-test.cc.

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

TEST() [21/138]

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

Definition at line 857 of file googletest-printers-test.cc.

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

TEST() [22/138]

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

Definition at line 765 of file googletest-printers-test.cc.

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

TEST() [23/138]

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

Definition at line 771 of file googletest-printers-test.cc.

                                          {
  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));
}

TEST() [24/138]

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

Definition at line 844 of file googletest-printers-test.cc.

                                                     {
  // 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));
}

TEST() [25/138]

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

Definition at line 851 of file googletest-printers-test.cc.

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

TEST() [26/138]

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

Definition at line 381 of file googletest-printers-test.cc.

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

TEST() [27/138]

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

Definition at line 453 of file googletest-printers-test.cc.

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

TEST() [28/138]

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

Definition at line 414 of file googletest-printers-test.cc.

                                    {
  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(std::numeric_limits<uint16_t>::max()));  // uint16
  EXPECT_EQ("-32768", Print(std::numeric_limits<int16_t>::min()));  // int16
  EXPECT_EQ("4294967295",
            Print(std::numeric_limits<uint32_t>::max()));  // uint32
  EXPECT_EQ("-2147483648",
            Print(std::numeric_limits<int32_t>::min()));  // int32
  EXPECT_EQ("18446744073709551615",
            Print(std::numeric_limits<uint64_t>::max()));  // uint64
  EXPECT_EQ("-9223372036854775808",
            Print(std::numeric_limits<int64_t>::min()));  // int64
#ifdef __cpp_char8_t
  EXPECT_EQ("U+0000",
            Print(std::numeric_limits<char8_t>::min()));  // char8_t
  EXPECT_EQ("U+00FF",
            Print(std::numeric_limits<char8_t>::max()));  // char8_t
#endif
  EXPECT_EQ("U+0000",
            Print(std::numeric_limits<char16_t>::min()));  // char16_t
  EXPECT_EQ("U+FFFF",
            Print(std::numeric_limits<char16_t>::max()));  // char16_t
  EXPECT_EQ("U+0000",
            Print(std::numeric_limits<char32_t>::min()));  // char32_t
  EXPECT_EQ("U+FFFFFFFF",
            Print(std::numeric_limits<char32_t>::max()));  // char32_t
}

TEST() [29/138]

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

Definition at line 444 of file googletest-printers-test.cc.

                                   {
  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
}

TEST() [30/138]

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

Definition at line 387 of file googletest-printers-test.cc.

                                    {
  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)));
}

TEST() [31/138]

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

Definition at line 630 of file googletest-printers-test.cc.

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

TEST() [32/138]

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

Definition at line 646 of file googletest-printers-test.cc.

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

TEST() [33/138]

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

Definition at line 622 of file googletest-printers-test.cc.

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

TEST() [34/138]

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

Definition at line 638 of file googletest-printers-test.cc.

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

TEST() [35/138]

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

Definition at line 364 of file googletest-printers-test.cc.

                            {
  EXPECT_EQ("U+0041", Print(u'A'));
}

TEST() [36/138]

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

Definition at line 368 of file googletest-printers-test.cc.

                            {
  EXPECT_EQ("U+0041", Print(U'A'));
}

TEST() [37/138]

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

Definition at line 331 of file googletest-printers-test.cc.

                               {
  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'));
}

TEST() [38/138]

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

Definition at line 351 of file googletest-printers-test.cc.

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

TEST() [39/138]

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

Definition at line 358 of file googletest-printers-test.cc.

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

TEST() [40/138]

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

Definition at line 324 of file googletest-printers-test.cc.

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

TEST() [41/138]

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

Definition at line 470 of file googletest-printers-test.cc.

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

TEST() [42/138]

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

Definition at line 489 of file googletest-printers-test.cc.

                                        {
  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));
}

TEST() [43/138]

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

Definition at line 476 of file googletest-printers-test.cc.

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

TEST() [44/138]

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

Definition at line 483 of file googletest-printers-test.cc.

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

TEST() [45/138]

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

Definition at line 302 of file googletest-printers-test.cc.

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

TEST() [46/138]

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

Definition at line 307 of file googletest-printers-test.cc.

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

TEST() [47/138]

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

Definition at line 317 of file googletest-printers-test.cc.

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

TEST() [48/138]

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

Definition at line 312 of file googletest-printers-test.cc.

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

TEST() [49/138]

testing::gtest_printers_test::TEST	(	PrintNullptrT	,
		Basic
	)

Definition at line 1229 of file googletest-printers-test.cc.

                           {
  EXPECT_EQ("(nullptr)", Print(nullptr));
}

TEST() [50/138]

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

Definition at line 744 of file googletest-printers-test.cc.

                                              {
  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 "));
}

TEST() [51/138]

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

Definition at line 732 of file googletest-printers-test.cc.

                                              {
  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 "));
}

TEST() [52/138]

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

Definition at line 691 of file googletest-printers-test.cc.

                                                 {
  // 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));
}

TEST() [53/138]

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

Definition at line 656 of file googletest-printers-test.cc.

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

TEST() [54/138]

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

Definition at line 672 of file googletest-printers-test.cc.

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

TEST() [55/138]

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

Definition at line 664 of file googletest-printers-test.cc.

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

TEST() [56/138]

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

Definition at line 680 of file googletest-printers-test.cc.

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

TEST() [57/138]

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

Definition at line 1322 of file googletest-printers-test.cc.

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

TEST() [58/138]

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

Definition at line 1329 of file googletest-printers-test.cc.

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

TEST() [59/138]

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

Definition at line 1335 of file googletest-printers-test.cc.

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

TEST() [60/138]

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

Definition at line 1361 of file googletest-printers-test.cc.

                                                 {
  void (*fp)(int n) = &MyFunction;
  const std::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 std::string fp_string = PrintPointer(reinterpret_cast<const void*>(
      reinterpret_cast<internal::BiggestInt>(fp)));
  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
            PrintByRef(fp));
}

TEST() [61/138]

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

Definition at line 1377 of file googletest-printers-test.cc.

                                                       {
  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 "));
}

TEST() [62/138]

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

Definition at line 1393 of file googletest-printers-test.cc.

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

TEST() [63/138]

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

Definition at line 1342 of file googletest-printers-test.cc.

                                                {
  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));
}

TEST() [64/138]

testing::gtest_printers_test::TEST	(	PrintReferenceWrapper	,
		Printable
	)

Definition at line 1233 of file googletest-printers-test.cc.

                                       {
  int x = 5;
  EXPECT_EQ("@" + PrintPointer(&x) + " 5", Print(std::ref(x)));
  EXPECT_EQ("@" + PrintPointer(&x) + " 5", Print(std::cref(x)));
}

TEST() [65/138]

testing::gtest_printers_test::TEST	(	PrintReferenceWrapper	,
		Unprintable
	)

Definition at line 1239 of file googletest-printers-test.cc.

                                         {
  ::foo::UnprintableInFoo up;
  EXPECT_EQ(
      "@" + PrintPointer(&up) +
          " 16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
      Print(std::ref(up)));
  EXPECT_EQ(
      "@" + PrintPointer(&up) +
          " 16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
      Print(std::cref(up)));
}

TEST() [66/138]

testing::gtest_printers_test::TEST	(	PrintStdTupleTest	,
		NestedTuple
	)

Definition at line 1223 of file googletest-printers-test.cc.

                                     {
  ::std::tuple< ::std::tuple<int, bool>, char> nested(
      ::std::make_tuple(5, true), 'a');
  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
}

TEST() [67/138]

testing::gtest_printers_test::TEST	(	PrintStdTupleTest	,
		VariousSizes
	)

Definition at line 1196 of file googletest-printers-test.cc.

                                      {
  ::std::tuple<> t0;
  EXPECT_EQ("()", Print(t0));
 
  ::std::tuple<int> t1(5);
  EXPECT_EQ("(5)", Print(t1));
 
  ::std::tuple<char, bool> t2('a', true);
  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
 
  ::std::tuple<bool, int, int> t3(false, 2, 3);
  EXPECT_EQ("(false, 2, 3)", Print(t3));
 
  ::std::tuple<bool, int, int, int> t4(false, 2, 3, 4);
  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
 
  const char* const str = "8";
  ::std::tuple<bool, char, short, int32_t, int64_t, float, double,  // NOLINT
               const char*, void*, std::string>
      t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,  // NOLINT
          nullptr, "10");
  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
            " pointing to \"8\", NULL, \"10\")",
            Print(t10));
}

TEST() [68/138]

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

Definition at line 1188 of file googletest-printers-test.cc.

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

TEST() [69/138]

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

Definition at line 1012 of file googletest-printers-test.cc.

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

TEST() [70/138]

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

Definition at line 1031 of file googletest-printers-test.cc.

                                          {
  ::std::unordered_multimap<int, bool> map1;
  map1.insert(make_pair(5, true));
  map1.insert(make_pair(5, false));
 
  // Elements of hash_multimap can be printed in any order.
  const std::string result = Print(map1);
  EXPECT_TRUE(result == "{ (5, true), (5, false) }" ||
              result == "{ (5, false), (5, true) }")
                  << " where Print(map1) returns \"" << result << "\".";
}

TEST() [71/138]

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

Definition at line 1051 of file googletest-printers-test.cc.

                                          {
  const int kSize = 5;
  int a[kSize] = { 1, 1, 2, 5, 1 };
  ::std::unordered_multiset<int> set1(a, a + kSize);
 
  // Elements of hash_multiset can be printed in any order.
  const std::string result = Print(set1);
  const std::string expected_pattern = "{ d, d, d, d, d }";  // d means a digit.
 
  // Verifies the result matches the expected pattern; also extracts
  // the numbers in the result.
  ASSERT_EQ(expected_pattern.length(), result.length());
  std::vector<int> numbers;
  for (size_t i = 0; i != result.length(); i++) {
    if (expected_pattern[i] == 'd') {
      ASSERT_NE(isdigit(static_cast<unsigned char>(result[i])), 0);
      numbers.push_back(result[i] - '0');
    } else {
      EXPECT_EQ(expected_pattern[i], result[i]) << " where result is "
                                                << result;
    }
  }
 
  // Makes sure the result contains the right numbers.
  std::sort(numbers.begin(), numbers.end());
  std::sort(a, a + kSize);
  EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
}

TEST() [72/138]

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

Definition at line 1045 of file googletest-printers-test.cc.

                                     {
  ::std::unordered_set<int> set1;
  set1.insert(1);
  EXPECT_EQ("{ 1 }", Print(set1));
}

TEST() [73/138]

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

Definition at line 1177 of file googletest-printers-test.cc.

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

TEST() [74/138]

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

Definition at line 1081 of file googletest-printers-test.cc.

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

TEST() [75/138]

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

Definition at line 1140 of file googletest-printers-test.cc.

                                          {
  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));
}

TEST() [76/138]

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

Definition at line 1087 of file googletest-printers-test.cc.

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

TEST() [77/138]

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

Definition at line 1095 of file googletest-printers-test.cc.

                                      {
  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));
}

TEST() [78/138]

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

Definition at line 1115 of file googletest-printers-test.cc.

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

TEST() [79/138]

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

Definition at line 1147 of file googletest-printers-test.cc.

                                             {
  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));
}

TEST() [80/138]

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

Definition at line 1017 of file googletest-printers-test.cc.

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

TEST() [81/138]

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

Definition at line 1159 of file googletest-printers-test.cc.

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

TEST() [82/138]

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

Definition at line 1025 of file googletest-printers-test.cc.

                                               {
  ::std::unordered_map<int, char> map1;
  map1[1] = 'a';
  EXPECT_EQ("{ (1, 'a' (97, 0x61)) }", Print(map1));
}

TEST() [83/138]

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

Definition at line 1128 of file googletest-printers-test.cc.

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

TEST() [84/138]

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

Definition at line 1109 of file googletest-printers-test.cc.

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

TEST() [85/138]

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

Definition at line 1122 of file googletest-printers-test.cc.

                                              {
  int a[] = { 9, 2, 8 };
  const std::forward_list<int> ints(a, a + 3);
  EXPECT_EQ("{ 9, 2, 8 }", Print(ints));
}

TEST() [86/138]

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

Definition at line 1165 of file googletest-printers-test.cc.

                                                       {
  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));
}

TEST() [87/138]

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

Definition at line 1133 of file googletest-printers-test.cc.

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

TEST() [88/138]

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

Definition at line 1286 of file googletest-printers-test.cc.

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

TEST() [89/138]

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

Definition at line 1314 of file googletest-printers-test.cc.

                                                       {
  ::foo::PathLike x;
  EXPECT_EQ("Streamable-PathLike", Print(x));
  const ::foo::PathLike cx;
  EXPECT_EQ("Streamable-PathLike", Print(cx));
}

TEST() [90/138]

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

Definition at line 1303 of file googletest-printers-test.cc.

                                                                    {
  ParentClass parent;
  ChildClassWithStreamOperator child_stream;
  ChildClassWithoutStreamOperator child_no_stream;
  EXPECT_EQ("ParentClass", Print(parent));
  EXPECT_EQ("ChildClassWithStreamOperator", Print(child_stream));
  EXPECT_EQ("ParentClass", Print(child_no_stream));
}

TEST() [91/138]

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

Definition at line 1293 of file googletest-printers-test.cc.

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

TEST() [92/138]

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

Definition at line 1298 of file googletest-printers-test.cc.

                                                                              {
  EXPECT_EQ("TemplatedStreamableInFoo",
            Print(::foo::TemplatedStreamableInFoo()));
}

TEST() [93/138]

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

Definition at line 879 of file googletest-printers-test.cc.

                                          {
  // "\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-!")));
}

TEST() [94/138]

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

Definition at line 872 of file googletest-printers-test.cc.

                                            {
  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));
}

TEST() [95/138]

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

Definition at line 923 of file googletest-printers-test.cc.

                                 {
  std::u16string str = u"Hello, 世界";
  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type.
  EXPECT_EQ("u\"Hello, \\x4E16\\x754C\"", Print(str));
}

TEST() [96/138]

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

Definition at line 929 of file googletest-printers-test.cc.

                                 {
  std::u32string str = U"Hello, 🗺️";
  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type
  EXPECT_EQ("U\"Hello, \\x1F5FA\\xFE0F\"", Print(str));
}

TEST() [97/138]

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

Definition at line 1603 of file googletest-printers-test.cc.

                                            {
  // Sanity test with valid UTF-8. Prints both in hex and as text.
  std::string non_ascii_str = ::std::string("오전 4:30");
  EXPECT_PRINT_TO_STRING_(non_ascii_str,
                          "\"\\xEC\\x98\\xA4\\xEC\\xA0\\x84 4:30\"\n"
                          "    As Text: \"오전 4:30\"");
  non_ascii_str = ::std::string("From ä — ẑ");
  EXPECT_PRINT_TO_STRING_(non_ascii_str,
                          "\"From \\xC3\\xA4 \\xE2\\x80\\x94 \\xE1\\xBA\\x91\""
                          "\n    As Text: \"From ä — ẑ\"");
}

TEST() [98/138]

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

Definition at line 1574 of file googletest-printers-test.cc.

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

TEST() [99/138]

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

Definition at line 1579 of file googletest-printers-test.cc.

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

TEST() [100/138]

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

Definition at line 1585 of file googletest-printers-test.cc.

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

TEST() [101/138]

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

Definition at line 1590 of file googletest-printers-test.cc.

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

TEST() [102/138]

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

Definition at line 1595 of file googletest-printers-test.cc.

                                                          {
  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\"");
}

TEST() [103/138]

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

Definition at line 1563 of file googletest-printers-test.cc.

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

TEST() [104/138]

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

Definition at line 1568 of file googletest-printers-test.cc.

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

TEST() [105/138]

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

Definition at line 1559 of file googletest-printers-test.cc.

                                        {
  EXPECT_PRINT_TO_STRING_(123, "123");
}

TEST() [106/138]

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

Definition at line 409 of file googletest-printers-test.cc.

                                 {
  EXPECT_LT(sizeof(wchar_t), sizeof(int64_t));
}

TEST() [107/138]

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

Definition at line 950 of file googletest-printers-test.cc.

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

TEST() [108/138]

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

Definition at line 967 of file googletest-printers-test.cc.

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

TEST() [109/138]

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

Definition at line 988 of file googletest-printers-test.cc.

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

TEST() [110/138]

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

Definition at line 527 of file googletest-printers-test.cc.

                                {
  const char16_t* p = u"界";
  EXPECT_EQ(PrintPointer(p) + " pointing to u\"\\x754C\"", Print(p));
}

TEST() [111/138]

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

Definition at line 546 of file googletest-printers-test.cc.

                                          {
  const char16_t* p = u"'\"?\\\a\b\f\n\r\t\v\x7F\xFF hello 世界";
  EXPECT_EQ(PrintPointer(p) +
                " pointing to u\"'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\x7F\\xFF "
                "hello \\x4E16\\x754C\"",
            Print(p));
}

TEST() [112/138]

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

Definition at line 533 of file googletest-printers-test.cc.

                                   {
  char16_t p[] = u"世";
  EXPECT_EQ(PrintPointer(p) + " pointing to u\"\\x4E16\"",
            Print(static_cast<char16_t*>(p)));
}

TEST() [113/138]

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

Definition at line 540 of file googletest-printers-test.cc.

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

TEST() [114/138]

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

Definition at line 555 of file googletest-printers-test.cc.

                                {
  const char32_t* p = U"🗺️";
  EXPECT_EQ(PrintPointer(p) + " pointing to U\"\\x1F5FA\\xFE0F\"", Print(p));
}

TEST() [115/138]

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

Definition at line 574 of file googletest-printers-test.cc.

                                          {
  const char32_t* p = U"'\"?\\\a\b\f\n\r\t\v\x7F\xFF hello 🗺️";
  EXPECT_EQ(PrintPointer(p) +
                " pointing to U\"'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\x7F\\xFF "
                "hello \\x1F5FA\\xFE0F\"",
            Print(p));
}

TEST() [116/138]

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

Definition at line 561 of file googletest-printers-test.cc.

                                   {
  char32_t p[] = U"🌌";
  EXPECT_EQ(PrintPointer(p) + " pointing to U\"\\x1F30C\"",
            Print(static_cast<char32_t*>(p)));
}

TEST() [117/138]

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

Definition at line 568 of file googletest-printers-test.cc.

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

TEST() [118/138]

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

Definition at line 1254 of file googletest-printers-test.cc.

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

TEST() [119/138]

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

Definition at line 1260 of file googletest-printers-test.cc.

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

TEST() [120/138]

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

Definition at line 1272 of file googletest-printers-test.cc.

                                         {
  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()));
}

TEST() [121/138]

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

Definition at line 591 of file googletest-printers-test.cc.

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

TEST() [122/138]

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

Definition at line 610 of file googletest-printers-test.cc.

                                            {
  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)));
}

TEST() [123/138]

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

Definition at line 597 of file googletest-printers-test.cc.

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

TEST() [124/138]

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

Definition at line 604 of file googletest-printers-test.cc.

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

TEST() [125/138]

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

Definition at line 1756 of file googletest-printers-test.cc.

                                         {
  struct Incomplete;
  char some_object = 0;
  EXPECT_EQ("(incomplete type)",
            PrintToString(reinterpret_cast<Incomplete&>(some_object)));
}

TEST() [126/138]

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

Definition at line 1763 of file googletest-printers-test.cc.

                                        {
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<int>()));
  std::unique_ptr<int> p(new int(17));
  EXPECT_EQ("(ptr = " + PrintPointer(p.get()) + ", value = 17)",
            PrintToString(p));
  std::unique_ptr<int[]> p2(new int[2]);
  EXPECT_EQ("(" + PrintPointer(p2.get()) + ")", PrintToString(p2));
 
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<int>()));
  std::shared_ptr<int> p3(new int(1979));
  EXPECT_EQ("(ptr = " + PrintPointer(p3.get()) + ", value = 1979)",
            PrintToString(p3));
#if __cpp_lib_shared_ptr_arrays >= 201611L
  std::shared_ptr<int[]> p4(new int[2]);
  EXPECT_EQ("(" + PrintPointer(p4.get()) + ")", PrintToString(p4));
#endif
 
  // modifiers
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<const int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<volatile int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<volatile const int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<int[]>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<const int[]>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<volatile int[]>()));
  EXPECT_EQ("(nullptr)",
            PrintToString(std::unique_ptr<volatile const int[]>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile const int>()));
#if __cpp_lib_shared_ptr_arrays >= 201611L
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<int[]>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int[]>()));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int[]>()));
  EXPECT_EQ("(nullptr)",
            PrintToString(std::shared_ptr<volatile const int[]>()));
#endif
 
  // void
  EXPECT_EQ("(nullptr)", PrintToString(std::unique_ptr<void, void (*)(void*)>(
                             nullptr, nullptr)));
  EXPECT_EQ("(" + PrintPointer(p.get()) + ")",
            PrintToString(
                std::unique_ptr<void, void (*)(void*)>(p.get(), [](void*) {})));
  EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<void>()));
  EXPECT_EQ("(" + PrintPointer(p.get()) + ")",
            PrintToString(std::shared_ptr<void>(p.get(), [](void*) {})));
}

TEST() [127/138]

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

Definition at line 1744 of file googletest-printers-test.cc.

                                            {
  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());
}

TEST() [128/138]

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

Definition at line 1727 of file googletest-printers-test.cc.

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

TEST() [129/138]

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

Definition at line 1707 of file googletest-printers-test.cc.

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

TEST() [130/138]

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

Definition at line 1720 of file googletest-printers-test.cc.

                                                {
  std::pair<const Wrapper<std::string>, int> p(Wrapper<std::string>("abc"), 1);
  ::std::stringstream ss;
  UniversalPrint(p, &ss);
  EXPECT_EQ("(Wrapper(\"abc\"), 1)", ss.str());
}

TEST() [131/138]

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

Definition at line 1713 of file googletest-printers-test.cc.

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

TEST() [132/138]

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

Definition at line 1690 of file googletest-printers-test.cc.

                                               {
  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 = nullptr;
  ::std::stringstream ss3;
  UniversalTersePrint(s3, &ss3);
  EXPECT_EQ("NULL", ss3.str());
}

TEST() [133/138]

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

Definition at line 1677 of file googletest-printers-test.cc.

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

TEST() [134/138]

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

Definition at line 1683 of file googletest-printers-test.cc.

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

TEST() [135/138]

testing::gtest_printers_test::TEST	(	UniversalTersePrintTupleFieldsToStringsTestWithStd	,
		PrintsEmptyTuple
	)

Definition at line 1813 of file googletest-printers-test.cc.

                                                                           {
  Strings result = UniversalTersePrintTupleFieldsToStrings(::std::make_tuple());
  EXPECT_EQ(0u, result.size());
}

TEST() [136/138]

testing::gtest_printers_test::TEST	(	UniversalTersePrintTupleFieldsToStringsTestWithStd	,
		PrintsOneTuple
	)

Definition at line 1818 of file googletest-printers-test.cc.

                                                                         {
  Strings result = UniversalTersePrintTupleFieldsToStrings(
      ::std::make_tuple(1));
  ASSERT_EQ(1u, result.size());
  EXPECT_EQ("1", result[0]);
}

TEST() [137/138]

testing::gtest_printers_test::TEST	(	UniversalTersePrintTupleFieldsToStringsTestWithStd	,
		PrintsTersely
	)

Definition at line 1833 of file googletest-printers-test.cc.

                                                                        {
  const int n = 1;
  Strings result = UniversalTersePrintTupleFieldsToStrings(
      ::std::tuple<const int&, const char*>(n, "a"));
  ASSERT_EQ(2u, result.size());
  EXPECT_EQ("1", result[0]);
  EXPECT_EQ("\"a\"", result[1]);
}

TEST() [138/138]

testing::gtest_printers_test::TEST	(	UniversalTersePrintTupleFieldsToStringsTestWithStd	,
		PrintsTwoTuple
	)

Definition at line 1825 of file googletest-printers-test.cc.

                                                                         {
  Strings result = UniversalTersePrintTupleFieldsToStrings(
      ::std::make_tuple(1, 'a'));
  ASSERT_EQ(2u, result.size());
  EXPECT_EQ("1", result[0]);
  EXPECT_EQ("'a' (97, 0x61)", result[1]);
}