55 # define GTEST_HAS_HASH_MAP_ 1 // Indicates that hash_map is available. 57 # define GTEST_HAS_HASH_SET_ 1 // Indicates that hash_set is available. 59 #endif // GTEST_OS_WINDOWS 81 return os << (e ==
kEWS1 ?
"kEWS1" :
"invalid");
90 *os << (e ==
kEWPT1 ?
"kEWPT1" :
"invalid");
100 template <
typename T>
115 os <<
"StreamableInGlobal";
119 os <<
"StreamableInGlobal*";
128 double z()
const {
return z_; }
141 *os <<
"PrintableViaPrintTo: " << x.
value;
150 return os <<
"PointerPrintable*";
154 template <
typename T>
159 const T&
value()
const {
return value_; }
164 template <
typename T>
166 *os <<
"PrintableViaPrintToTemplate: " << x.
value();
170 template <
typename T>
175 const T&
value()
const {
return value_; }
180 template <
typename T>
183 return os <<
"StreamableTemplateInFoo: " << x.
value();
189 namespace gtest_printers_test {
193 using ::std::make_pair;
195 using ::std::multimap;
196 using ::std::multiset;
203 using ::testing::internal::NativeArray;
204 using ::testing::internal::RE;
205 using ::testing::internal::RelationToSourceReference;
208 using ::testing::internal::UniversalPrinter;
210 using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
216 #ifdef _STLP_HASH_MAP // We got <hash_map> from STLport. 217 using ::std::hash_map;
218 using ::std::hash_set;
219 using ::std::hash_multimap;
220 using ::std::hash_multiset;
222 using ::stdext::hash_map;
223 using ::stdext::hash_set;
224 using ::stdext::hash_multimap;
225 using ::stdext::hash_multiset;
230 template <
typename T>
232 ::std::stringstream ss;
240 template <
typename T>
242 ::std::stringstream ss;
278 TEST(PrintCharTest, PlainChar) {
298 TEST(PrintCharTest, SignedChar) {
301 Print(static_cast<signed char>(-50)));
305 TEST(PrintCharTest, UnsignedChar) {
308 Print(static_cast<unsigned char>(
'b')));
320 TEST(PrintBuiltInTypeTest, Wchar_t) {
337 EXPECT_EQ(
"L'\\x576' (1398)",
Print(static_cast<wchar_t>(0x576)));
338 EXPECT_EQ(
"L'\\xC74D' (51021)",
Print(static_cast<wchar_t>(0xC74D)));
342 TEST(PrintTypeSizeTest, Wchar_t) {
347 TEST(PrintBuiltInTypeTest, Integer) {
348 EXPECT_EQ(
"'\\xFF' (255)",
Print(static_cast<unsigned char>(255)));
349 EXPECT_EQ(
"'\\x80' (-128)",
Print(static_cast<signed char>(-128)));
355 Print(static_cast<testing::internal::UInt64>(-1)));
357 Print(static_cast<testing::internal::Int64>(1) << 63));
361 TEST(PrintBuiltInTypeTest, Size_t) {
363 #if !GTEST_OS_WINDOWS 366 #endif // !GTEST_OS_WINDOWS 370 TEST(PrintBuiltInTypeTest, FloatingPoints) {
379 ::std::stringstream expected_result_stream;
380 expected_result_stream <<
p;
381 return expected_result_stream.str();
387 TEST(PrintCStringTest, Const) {
388 const char*
p =
"World";
393 TEST(PrintCStringTest, NonConst) {
396 Print(static_cast<char*>(p)));
401 const char*
p = NULL;
406 TEST(PrintCStringTest, EscapesProperly) {
407 const char*
p =
"'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
409 "\\n\\r\\t\\v\\x7F\\xFF a\"",
419 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) 422 TEST(PrintWideCStringTest, Const) {
423 const wchar_t*
p = L
"World";
428 TEST(PrintWideCStringTest, NonConst) {
431 Print(static_cast<wchar_t*>(p)));
435 TEST(PrintWideCStringTest, Null) {
436 const wchar_t*
p = NULL;
441 TEST(PrintWideCStringTest, EscapesProperly) {
442 const wchar_t s[] = {
'\'',
'"',
'?',
'\\',
'\a',
'\b',
'\f',
'\n',
'\r',
443 '\t',
'\v', 0xD3, 0x576, 0x8D3, 0xC74D,
' ',
'a',
'\0'};
445 "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
446 Print(static_cast<const wchar_t*>(s)));
448 #endif // native wchar_t 453 TEST(PrintCharPointerTest, SignedChar) {
454 signed char*
p =
reinterpret_cast<signed char*
>(0x1234);
461 TEST(PrintCharPointerTest, ConstSignedChar) {
462 signed char*
p =
reinterpret_cast<signed char*
>(0x1234);
469 TEST(PrintCharPointerTest, UnsignedChar) {
470 unsigned char*
p =
reinterpret_cast<unsigned char*
>(0x1234);
477 TEST(PrintCharPointerTest, ConstUnsignedChar) {
478 const unsigned char*
p =
reinterpret_cast<const unsigned char*
>(0x1234);
488 bool*
p =
reinterpret_cast<bool*
>(0xABCD);
495 TEST(PrintPointerToBuiltInTypeTest, Void) {
496 void*
p =
reinterpret_cast<void*
>(0xABCD);
503 TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
504 const void*
p =
reinterpret_cast<const void*
>(0xABCD);
511 TEST(PrintPointerToPointerTest, IntPointerPointer) {
512 int**
p =
reinterpret_cast<int**
>(0xABCD);
522 TEST(PrintPointerTest, NonMemberFunctionPointer) {
529 reinterpret_cast<internal::BiggestInt>(&
MyFunction))),
531 int (*
p)(
bool) = NULL;
537 template <
typename StringType>
539 if (str.find(prefix, 0) == 0)
542 const bool is_wide_string =
sizeof(prefix[0]) > 1;
543 const char*
const begin_string_quote = is_wide_string ?
"L\"" :
"\"";
545 << begin_string_quote << prefix <<
"\" is not a prefix of " 546 << begin_string_quote << str <<
"\"\n";
563 TEST(PrintPointerTest, MemberVariablePointer) {
566 int (
Foo::*
p) = NULL;
568 Print(
sizeof(p)) +
"-byte object "));
575 TEST(PrintPointerTest, MemberFunctionPointer) {
577 Print(
sizeof(&Foo::MyMethod)) +
"-byte object "));
580 Print(
sizeof((&Foo::MyVirtualMethod))) +
"-byte object "));
581 int (
Foo::*
p)(char) = NULL;
583 Print(
sizeof(p)) +
"-byte object "));
590 template <
typename T,
size_t N>
596 TEST(PrintArrayTest, OneDimensionalArray) {
597 int a[5] = { 1, 2, 3, 4, 5 };
602 TEST(PrintArrayTest, TwoDimensionalArray) {
607 EXPECT_EQ(
"{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }",
PrintArrayHelper(a));
611 TEST(PrintArrayTest, ConstArray) {
612 const bool a[1] = {
false };
617 TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
619 char a[] = {
'H',
'\0',
'i' };
624 TEST(PrintArrayTest, ConstCharArrayWithTerminatingNul) {
625 const char a[] =
"\0Hi";
630 TEST(PrintArrayTest, WCharArrayWithNoTerminatingNul) {
632 const wchar_t a[] = { L
'H', L
'\0', L
'i' };
637 TEST(PrintArrayTest, WConstCharArrayWithTerminatingNul) {
638 const wchar_t a[] = L
"\0Hi";
643 TEST(PrintArrayTest, ObjectArray) {
644 string a[3] = {
"Hi",
"Hello",
"Ni hao" };
649 TEST(PrintArrayTest, BigArray) {
650 int a[100] = { 1, 2, 3 };
651 EXPECT_EQ(
"{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
657 #if GTEST_HAS_GLOBAL_STRING 659 TEST(PrintStringTest, StringInGlobalNamespace) {
660 const char s[] =
"'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
662 EXPECT_EQ(
"\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
665 #endif // GTEST_HAS_GLOBAL_STRING 668 TEST(PrintStringTest, StringInStdNamespace) {
669 const char s[] =
"'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
671 EXPECT_EQ(
"\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
675 TEST(PrintStringTest, StringAmbiguousHex) {
691 #if GTEST_HAS_GLOBAL_WSTRING 693 TEST(PrintWideStringTest, StringInGlobalNamespace) {
694 const wchar_t s[] = L
"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
696 EXPECT_EQ(
"L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v" 697 "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
700 #endif // GTEST_HAS_GLOBAL_WSTRING 702 #if GTEST_HAS_STD_WSTRING 704 TEST(PrintWideStringTest, StringInStdNamespace) {
705 const wchar_t s[] = L
"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
707 EXPECT_EQ(
"L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v" 708 "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
712 TEST(PrintWideStringTest, StringAmbiguousHex) {
721 #endif // GTEST_HAS_STD_WSTRING 731 template <
typename Char,
typename CharTraits>
733 std::basic_ostream<Char, CharTraits>& os,
735 return os <<
"AllowsGenericStreaming";
738 TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
745 template <
typename T>
748 template <
typename Char,
typename CharTraits,
typename T>
750 std::basic_ostream<Char, CharTraits>& os,
752 return os <<
"AllowsGenericStreamingTemplate";
755 TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
763 template <
typename T>
766 operator bool()
const {
return false; }
769 template <
typename Char,
typename CharTraits,
typename T>
771 std::basic_ostream<Char, CharTraits>& os,
773 return os <<
"AllowsGenericStreamingAndImplicitConversionTemplate";
776 TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
778 EXPECT_EQ(
"AllowsGenericStreamingAndImplicitConversionTemplate",
Print(a));
781 #if GTEST_HAS_STRING_PIECE_ 785 TEST(PrintStringPieceTest, SimpleStringPiece) {
786 const StringPiece sp =
"Hello";
790 TEST(PrintStringPieceTest, UnprintableCharacters) {
791 const char str[] =
"NUL (\0) and \r\t";
792 const StringPiece sp(str,
sizeof(str) - 1);
796 #endif // GTEST_HAS_STRING_PIECE_ 800 TEST(PrintStlContainerTest, EmptyDeque) {
805 TEST(PrintStlContainerTest, NonEmptyDeque) {
806 deque<int> non_empty;
807 non_empty.push_back(1);
808 non_empty.push_back(3);
812 #if GTEST_HAS_HASH_MAP_ 814 TEST(PrintStlContainerTest, OneElementHashMap) {
815 hash_map<int, char> map1;
820 TEST(PrintStlContainerTest, HashMultiMap) {
821 hash_multimap<int, bool> map1;
822 map1.insert(make_pair(5,
true));
823 map1.insert(make_pair(5,
false));
827 EXPECT_TRUE(result ==
"{ (5, true), (5, false) }" ||
828 result ==
"{ (5, false), (5, true) }")
829 <<
" where Print(map1) returns \"" << result <<
"\".";
832 #endif // GTEST_HAS_HASH_MAP_ 834 #if GTEST_HAS_HASH_SET_ 836 TEST(PrintStlContainerTest, HashSet) {
837 hash_set<string> set1;
838 set1.insert(
"hello");
842 TEST(PrintStlContainerTest, HashMultiSet) {
844 int a[kSize] = { 1, 1, 2, 5, 1 };
845 hash_multiset<int> set1(a, a + kSize);
849 const string expected_pattern =
"{ d, d, d, d, d }";
853 ASSERT_EQ(expected_pattern.length(), result.length());
854 std::vector<int> numbers;
855 for (
size_t i = 0;
i != result.length();
i++) {
856 if (expected_pattern[
i] ==
'd') {
857 ASSERT_NE(isdigit(static_cast<unsigned char>(result[
i])), 0);
858 numbers.push_back(result[i] -
'0');
860 EXPECT_EQ(expected_pattern[
i], result[i]) <<
" where result is " 866 std::sort(numbers.begin(), numbers.end());
867 std::sort(a, a + kSize);
868 EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
871 #endif // GTEST_HAS_HASH_SET_ 873 TEST(PrintStlContainerTest, List) {
878 const list<string> strings(a, a + 2);
882 TEST(PrintStlContainerTest, Map) {
890 TEST(PrintStlContainerTest, MultiMap) {
891 multimap<bool, int> map1;
898 map1.insert(pair<const bool, int>(
true, 0));
899 map1.insert(pair<const bool, int>(
true, 1));
900 map1.insert(pair<const bool, int>(
false, 2));
904 TEST(PrintStlContainerTest, Set) {
905 const unsigned int a[] = { 3, 0, 5 };
906 set<unsigned int> set1(a, a + 3);
910 TEST(PrintStlContainerTest, MultiSet) {
911 const int a[] = { 1, 1, 2, 5, 1 };
912 multiset<int> set1(a, a + 5);
916 TEST(PrintStlContainerTest, Pair) {
917 pair<const bool, int>
p(
true, 5);
921 TEST(PrintStlContainerTest, Vector) {
928 TEST(PrintStlContainerTest, LongSequence) {
929 const int a[100] = { 1, 2, 3 };
930 const vector<int> v(a, a + 100);
931 EXPECT_EQ(
"{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, " 932 "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }",
Print(v));
935 TEST(PrintStlContainerTest, NestedContainer) {
936 const int a1[] = { 1, 2 };
937 const int a2[] = { 3, 4, 5 };
938 const list<int> l1(a1, a1 + 2);
939 const list<int> l2(a2, a2 + 3);
941 vector<list<int> > v;
947 TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
948 const int a[3] = { 1, 2, 3 };
949 NativeArray<int> b(a, 3, RelationToSourceReference());
953 TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
954 const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
955 NativeArray<int[3]> b(a, 2, RelationToSourceReference());
965 TEST(PrintStlContainerTest, Iterator) {
976 TEST(PrintStlContainerTest, ConstIterator) {
981 #if GTEST_HAS_TR1_TUPLE 985 TEST(PrintTr1TupleTest, VariousSizes) {
1004 ::std::tr1::tuple<bool, int, int, int, bool, int> t6(
false, 2, 3, 4,
true, 6);
1008 false, 2, 3, 4,
true, 6, 7);
1012 false, 2, 3, 4,
true, 6, 7,
true);
1016 false, 2, 3, 4,
true, 6, 7,
true, 9);
1019 const char*
const str =
"8";
1024 t10(
false,
'a', 3, 4, 5, 1.5
F, -2.5, str,
1025 ImplicitCast_<void*>(NULL),
"10");
1027 " pointing to \"8\", NULL, \"10\")",
1032 TEST(PrintTr1TupleTest, NestedTuple) {
1038 #endif // GTEST_HAS_TR1_TUPLE 1040 #if GTEST_HAS_STD_TUPLE_ 1044 TEST(PrintStdTupleTest, VariousSizes) {
1048 ::std::tuple<int> t1(5);
1051 ::std::tuple<char, bool> t2(
'a',
true);
1054 ::std::tuple<bool, int, int> t3(
false, 2, 3);
1057 ::std::tuple<bool, int, int, int> t4(
false, 2, 3, 4);
1060 ::std::tuple<bool, int, int, int, bool> t5(
false, 2, 3, 4,
true);
1063 ::std::tuple<bool, int, int, int, bool, int> t6(
false, 2, 3, 4,
true, 6);
1066 ::std::tuple<bool, int, int, int, bool, int, int> t7(
1067 false, 2, 3, 4,
true, 6, 7);
1070 ::std::tuple<bool, int, int, int, bool, int, int, bool> t8(
1071 false, 2, 3, 4,
true, 6, 7,
true);
1074 ::std::tuple<bool, int, int, int, bool, int, int, bool, int> t9(
1075 false, 2, 3, 4,
true, 6, 7,
true, 9);
1078 const char*
const str =
"8";
1083 t10(
false,
'a', 3, 4, 5, 1.5
F, -2.5, str,
1084 ImplicitCast_<void*>(NULL),
"10");
1086 " pointing to \"8\", NULL, \"10\")",
1091 TEST(PrintStdTupleTest, NestedTuple) {
1092 ::std::tuple< ::std::tuple<int, bool>,
char> nested(
1097 #endif // GTEST_LANG_CXX11 1102 TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
1108 TEST(PrintUnprintableTypeTest, InUserNamespace) {
1109 EXPECT_EQ(
"16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1116 Big() { memset(array, 0,
sizeof(array)); }
1120 TEST(PrintUnpritableTypeTest, BigObject) {
1121 EXPECT_EQ(
"257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 " 1122 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 " 1123 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 " 1124 "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 " 1125 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 " 1126 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 " 1127 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
1134 TEST(PrintStreamableTypeTest, InGlobalNamespace) {
1141 TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
1147 TEST(PrintPrintableTypeTest, InUserNamespace) {
1154 TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
1160 TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
1161 EXPECT_EQ(
"PrintableViaPrintToTemplate: 5",
1165 #if GTEST_HAS_PROTOBUF_ 1168 TEST(PrintProto2MessageTest, PrintsShortDebugStringWhenItIsShort) {
1169 testing::internal::FooMessage msg;
1170 msg.set_int_field(2);
1171 msg.set_string_field(
"hello");
1173 "<int_field:\\s*2\\s+string_field:\\s*\"hello\">");
1177 TEST(PrintProto2MessageTest, PrintsDebugStringWhenItIsLong) {
1178 testing::internal::FooMessage msg;
1179 msg.set_int_field(2);
1180 msg.set_string_field(
"hello");
1181 msg.add_names(
"peter");
1182 msg.add_names(
"paul");
1183 msg.add_names(
"mary");
1187 "string_field:\\s*\"hello\"\n" 1188 "names:\\s*\"peter\"\n" 1189 "names:\\s*\"paul\"\n" 1190 "names:\\s*\"mary\"\n" 1194 #endif // GTEST_HAS_PROTOBUF_ 1198 TEST(PrintReferenceTest, PrintsAddressAndValue) {
1209 const ::foo::UnprintableInFoo
x;
1211 "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1217 TEST(PrintReferenceTest, HandlesFunctionPointer) {
1219 const string fp_pointer_string =
1225 const string fp_string =
PrintPointer(reinterpret_cast<const void*>(
1226 reinterpret_cast<internal::BiggestInt>(fp)));
1227 EXPECT_EQ(
"@" + fp_pointer_string +
" " + fp_string,
1233 TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
1234 int (
Foo::*
p)(
char ch) = &Foo::MyMethod;
1237 "@" +
PrintPointer(reinterpret_cast<const void*>(&p)) +
" " +
1238 Print(
sizeof(p)) +
"-byte object "));
1240 char (
Foo::*p2)(
int n) = &Foo::MyVirtualMethod;
1243 "@" +
PrintPointer(reinterpret_cast<const void*>(&p2)) +
" " +
1244 Print(
sizeof(p2)) +
"-byte object "));
1249 TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
1261 TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
1267 TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
1274 TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer) {
1277 int n[] = { 1, 2, 3 };
1287 TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer) {
1294 const char*
s =
"hello";
1305 TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer) {
1312 const wchar_t*
s = L
"hello";
1325 #if GTEST_HAS_GLOBAL_STRING 1327 TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsString) {
1328 const char*
s =
"hello \"world";
1333 char str[] =
"hi\1";
1341 TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsStdString) {
1342 const char*
s =
"hello \"world";
1347 char str[] =
"hi\1";
1353 #if GTEST_HAS_GLOBAL_WSTRING 1355 TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsWString) {
1356 const wchar_t*
s = L
"hi \"world";
1361 wchar_t str[] = L
"hi\1";
1368 #if GTEST_HAS_STD_WSTRING 1370 TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsStdWString) {
1371 const wchar_t*
s = L
"hi \"world";
1376 wchar_t str[] = L
"hi\1";
1388 TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) {
1389 char str[] =
"hi \"world\"";
1396 TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray) {
1397 const char str[] =
"hi \"world\"";
1403 TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) {
1404 wchar_t str[] = L
"hi \"world\"";
1411 TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCharArray) {
1412 const wchar_t str[] = L
"hi \"world\"";
1420 #if GTEST_HAS_GLOBAL_STRING 1422 TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsString) {
1423 const char str[] =
"hi \"w\0rld\"";
1431 TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdString) {
1432 const char str[] =
"hi \"world\"";
1437 #if GTEST_HAS_GLOBAL_WSTRING 1439 TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWString) {
1440 const wchar_t str[] = L
"hi \"world\"";
1446 #if GTEST_HAS_STD_WSTRING 1448 TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
1449 const wchar_t str[] = L
"hi \"w\0rld\"";
1460 #define EXPECT_PRINT_TO_STRING_(value, expected_string) \ 1461 EXPECT_TRUE(PrintToString(value) == (expected_string)) \ 1462 << " where " #value " prints as " << (PrintToString(value)) 1464 TEST(PrintToStringTest, WorksForScalar) {
1468 TEST(PrintToStringTest, WorksForPointerToConstChar) {
1469 const char*
p =
"hello";
1473 TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
1479 TEST(PrintToStringTest, EscapesForPointerToConstChar) {
1480 const char*
p =
"hello\n";
1484 TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
1485 char s[] =
"hello\1";
1490 TEST(PrintToStringTest, WorksForArray) {
1491 int n[3] = { 1, 2, 3 };
1495 TEST(PrintToStringTest, WorksForCharArray) {
1500 TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
1501 const char str_with_nul[] =
"hello\0 world";
1504 char mutable_str_with_nul[] =
"hello\0 world";
1508 #undef EXPECT_PRINT_TO_STRING_ 1510 TEST(UniversalTersePrintTest, WorksForNonReference) {
1511 ::std::stringstream ss;
1516 TEST(UniversalTersePrintTest, WorksForReference) {
1518 ::std::stringstream ss;
1523 TEST(UniversalTersePrintTest, WorksForCString) {
1524 const char* s1 =
"abc";
1525 ::std::stringstream ss1;
1529 char* s2 =
const_cast<char*
>(s1);
1530 ::std::stringstream ss2;
1534 const char* s3 = NULL;
1535 ::std::stringstream ss3;
1540 TEST(UniversalPrintTest, WorksForNonReference) {
1541 ::std::stringstream ss;
1546 TEST(UniversalPrintTest, WorksForReference) {
1548 ::std::stringstream ss;
1553 TEST(UniversalPrintTest, WorksForCString) {
1554 const char* s1 =
"abc";
1555 ::std::stringstream ss1;
1559 char* s2 =
const_cast<char*
>(s1);
1560 ::std::stringstream ss2;
1564 const char* s3 = NULL;
1565 ::std::stringstream ss3;
1570 TEST(UniversalPrintTest, WorksForCharArray) {
1571 const char str[] =
"\"Line\0 1\"\nLine 2";
1572 ::std::stringstream ss1;
1574 EXPECT_EQ(
"\"\\\"Line\\0 1\\\"\\nLine 2\"", ss1.str());
1576 const char mutable_str[] =
"\"Line\0 1\"\nLine 2";
1577 ::std::stringstream ss2;
1579 EXPECT_EQ(
"\"\\\"Line\\0 1\\\"\\nLine 2\"", ss2.str());
1582 #if GTEST_HAS_TR1_TUPLE 1584 TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsEmptyTuple) {
1590 TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsOneTuple) {
1597 TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTwoTuple) {
1605 TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTersely) {
1614 #endif // GTEST_HAS_TR1_TUPLE 1616 #if GTEST_HAS_STD_TUPLE_ 1618 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
1623 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple) {
1630 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple) {
1638 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely) {
1641 ::std::tuple<const int&, const char*>(n,
"a"));
1647 #endif // GTEST_HAS_STD_TUPLE_
#define EXPECT_PRINT_TO_STRING_(value, expected_string)
GTEST_API_ AssertionResult AssertionFailure()
#define ASSERT_NE(val1, val2)
::std::string PrintToString(const T &value)
UnprintableTemplateInGlobal()
void UniversalTersePrint(const T &value,::std::ostream *os)
static string PrintPointer(const void *p)
#define ASSERT_EQ(val1, val2)
std::ostream & operator<<(std::ostream &os, EnumWithStreaming e)
void PrintTo(EnumWithPrintTo e, std::ostream *os)
std::string FormatForComparisonFailureMessage(const T1 &value, const T2 &)
#define EXPECT_LT(val1, val2)
UNITTEST_START int result
string PrintArrayHelper(T(&a)[N])
TypeWithSize< 4 >::Int Int32
memcpy(filename, filename1, strlen(filename1))
GTEST_API_ AssertionResult AssertionSuccess()
string Print(const T &value)
string PrintByRef(const T &value)
void UniversalPrint(const T &value,::std::ostream *os)
#define EXPECT_STREQ(expected, actual)
PrintableViaPrintToTemplate(const T &a_value)
TFSIMD_FORCE_INLINE const tfScalar & x() const
virtual ~StreamableInGlobal()
#define EXPECT_EQ(expected, actual)
AssertionResult HasPrefix(const StringType &str, const StringType &prefix)
virtual char MyVirtualMethod(int)
::std::vector< string > Strings
StreamableTemplateInFoo()
UNITTEST_START int * value
TEST(UniversalPrintTest, WorksForCharArray)
#define EXPECT_TRUE(condition)
TypeWithSize< 8 >::Int Int64
#define EXPECT_PRED2(pred, v1, v2)