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 (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 (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, 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 (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, WorksForCString)
	TEST (UniversalPrintTest, WorksForCharArray)

Function Documentation

HasPrefix()

template<typename StringType >

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

Definition at line 547 of file gtest-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";
}

Here is the call graph for this function:

Here is the caller graph for this function:

MyFunction()

void testing::gtest_printers_test::MyFunction

(

int

)

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

{}

Here is the caller graph for this function:

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 684 of file gtest-printers_test.cc.

                                     {
  return os << "AllowsGenericStreaming";
}

Here is the call graph for this function:

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 764 of file gtest-printers_test.cc.

                                                                     {
  return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
}

Here is the call graph for this function:

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 747 of file gtest-printers_test.cc.

                                                {
  return os << "AllowsGenericStreamingTemplate";
}

Here is the call graph for this function:

Print()

template<typename T >

std::string testing::gtest_printers_test::Print

(

const T &

value

)

Definition at line 240 of file gtest-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 600 of file gtest-printers_test.cc.

                                      {
  return Print(a);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintByRef()

template<typename T >

std::string testing::gtest_printers_test::PrintByRef

(

const T &

value

)

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

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

Here is the caller graph for this function:

TEST() [1/103]

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

Definition at line 1277 of file gtest-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/103]

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

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

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

TEST() [3/103]

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

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

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

TEST() [4/103]

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

Definition at line 1434 of file gtest-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/103]

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

Definition at line 1290 of file gtest-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/103]

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

Definition at line 1344 of file gtest-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/103]

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

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

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

TEST() [8/103]

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

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

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

TEST() [9/103]

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

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

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

TEST() [10/103]

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

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

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

TEST() [11/103]

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

Definition at line 1308 of file gtest-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/103]

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

Definition at line 1523 of file gtest-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/103]

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

Definition at line 658 of file gtest-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));
}

Here is the call graph for this function:

TEST() [14/103]

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

Definition at line 626 of file gtest-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));
}

Here is the call graph for this function:

TEST() [15/103]

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

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

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

Here is the call graph for this function:

TEST() [16/103]

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

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

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

Here is the call graph for this function:

TEST() [17/103]

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

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

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

Here is the call graph for this function:

TEST() [18/103]

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

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

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

Here is the call graph for this function:

TEST() [19/103]

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

Definition at line 611 of file gtest-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));
}

Here is the call graph for this function:

TEST() [20/103]

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

Definition at line 639 of file gtest-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));
}

Here is the call graph for this function:

TEST() [21/103]

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

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

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

Here is the call graph for this function:

TEST() [22/103]

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

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

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

Here is the call graph for this function:

TEST() [23/103]

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

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

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

Here is the call graph for this function:

TEST() [24/103]

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

Definition at line 356 of file gtest-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(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
}

Here is the call graph for this function:

TEST() [25/103]

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

Definition at line 370 of file gtest-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
}

Here is the call graph for this function:

TEST() [26/103]

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

Definition at line 329 of file gtest-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)));
}

Here is the call graph for this function:

TEST() [27/103]

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

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

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

Here is the call graph for this function:

TEST() [28/103]

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

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

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

Here is the call graph for this function:

TEST() [29/103]

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

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

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

Here is the call graph for this function:

TEST() [30/103]

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

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

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

Here is the call graph for this function:

TEST() [31/103]

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

Definition at line 287 of file gtest-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'));
}

Here is the call graph for this function:

TEST() [32/103]

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

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

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

Here is the call graph for this function:

TEST() [33/103]

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

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

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

Here is the call graph for this function:

TEST() [34/103]

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

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

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

Here is the call graph for this function:

TEST() [35/103]

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

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

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

Here is the call graph for this function:

TEST() [36/103]

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

Definition at line 415 of file gtest-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));
}

Here is the call graph for this function:

TEST() [37/103]

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

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

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

Here is the call graph for this function:

TEST() [38/103]

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

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

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

Here is the call graph for this function:

TEST() [39/103]

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

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

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

Here is the call graph for this function:

TEST() [40/103]

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

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

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

Here is the call graph for this function:

TEST() [41/103]

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

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

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

Here is the call graph for this function:

TEST() [42/103]

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

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

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

Here is the call graph for this function:

TEST() [43/103]

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

Definition at line 584 of file gtest-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 "));
}

Here is the call graph for this function:

TEST() [44/103]

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

Definition at line 572 of file gtest-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 "));
}

Here is the call graph for this function:

TEST() [45/103]

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

Definition at line 531 of file gtest-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));
}

Here is the call graph for this function:

TEST() [46/103]

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

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

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

Here is the call graph for this function:

TEST() [47/103]

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

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

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

Here is the call graph for this function:

TEST() [48/103]

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

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

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

Here is the call graph for this function:

TEST() [49/103]

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

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

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

Here is the call graph for this function:

TEST() [50/103]

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

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

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

Here is the call graph for this function:

TEST() [51/103]

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

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

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

Here is the call graph for this function:

TEST() [52/103]

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

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

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

Here is the call graph for this function:

TEST() [53/103]

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

Definition at line 1220 of file gtest-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));
}

Here is the call graph for this function:

TEST() [54/103]

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

Definition at line 1236 of file gtest-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 "));
}

Here is the call graph for this function:

TEST() [55/103]

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

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

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

Here is the call graph for this function:

TEST() [56/103]

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

Definition at line 1201 of file gtest-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));
}

Here is the call graph for this function:

TEST() [57/103]

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

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

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

Here is the call graph for this function:

TEST() [58/103]

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

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

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

Here is the call graph for this function:

TEST() [59/103]

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

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

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

Here is the call graph for this function:

TEST() [60/103]

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

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

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

Here is the call graph for this function:

TEST() [61/103]

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

Definition at line 945 of file gtest-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));
}

Here is the call graph for this function:

TEST() [62/103]

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

Definition at line 888 of file gtest-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));
}

Here is the call graph for this function:

TEST() [63/103]

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

Definition at line 896 of file gtest-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));
}

Here is the call graph for this function:

TEST() [64/103]

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

Definition at line 916 of file gtest-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));
}

Here is the call graph for this function:

TEST() [65/103]

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

Definition at line 952 of file gtest-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));
}

Here is the call graph for this function:

TEST() [66/103]

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

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

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

Here is the call graph for this function:

TEST() [67/103]

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

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

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

Here is the call graph for this function:

TEST() [68/103]

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

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

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

Here is the call graph for this function:

TEST() [69/103]

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

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

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

Here is the call graph for this function:

TEST() [70/103]

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

Definition at line 970 of file gtest-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));
}

Here is the call graph for this function:

TEST() [71/103]

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

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

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

Here is the call graph for this function:

TEST() [72/103]

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

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

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

Here is the call graph for this function:

TEST() [73/103]

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

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

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

Here is the call graph for this function:

TEST() [74/103]

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

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

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

Here is the call graph for this function:

TEST() [75/103]

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

Definition at line 684 of file gtest-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() [76/103]

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

Definition at line 677 of file gtest-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));
}

Here is the call graph for this function:

TEST() [77/103]

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

Definition at line 1511 of file gtest-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() [78/103]

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

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

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

TEST() [79/103]

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

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

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

TEST() [80/103]

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

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

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

TEST() [81/103]

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

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

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

TEST() [82/103]

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

Definition at line 1503 of file gtest-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() [83/103]

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

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

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

TEST() [84/103]

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

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

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

TEST() [85/103]

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

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

                                        {
  EXPECT_PRINT_TO_STRING_(123, "123");
}

TEST() [86/103]

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

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

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

TEST() [87/103]

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

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

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

TEST() [88/103]

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

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

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

TEST() [89/103]

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

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

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

Here is the call graph for this function:

TEST() [90/103]

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

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

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

Here is the call graph for this function:

TEST() [91/103]

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

Definition at line 1133 of file gtest-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()));
}

Here is the call graph for this function:

TEST() [92/103]

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

Definition at line 1145 of file gtest-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()));
}

Here is the call graph for this function:

TEST() [93/103]

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

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

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

Here is the call graph for this function:

TEST() [94/103]

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

Definition at line 450 of file gtest-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)));
}

Here is the call graph for this function:

TEST() [95/103]

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

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

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

Here is the call graph for this function:

TEST() [96/103]

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

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

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

Here is the call graph for this function:

TEST() [97/103]

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

Definition at line 1645 of file gtest-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() [98/103]

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

Definition at line 1628 of file gtest-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 = NULL;
  ::std::stringstream ss3;
  UniversalPrint(s3, &ss3);
  EXPECT_EQ("NULL", ss3.str());
}

TEST() [99/103]

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

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

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

TEST() [100/103]

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

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

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

TEST() [101/103]

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

Definition at line 1598 of file gtest-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 = NULL;
  ::std::stringstream ss3;
  UniversalTersePrint(s3, &ss3);
  EXPECT_EQ("NULL", ss3.str());
}

TEST() [102/103]

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

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

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

TEST() [103/103]

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

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

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