40#include <forward_list>
47#include <unordered_map>
48#include <unordered_set>
75 return os << (e ==
kEWS1 ?
"kEWS1" :
"invalid");
84 *os << (e ==
kEWPT1 ?
"kEWPT1" :
"invalid");
90 operator ::testing::internal::BiggestInt()
const {
return 42; }
109 os <<
"StreamableInGlobal";
113 os <<
"StreamableInGlobal*";
122 double z()
const {
return z_; }
135 *os <<
"PrintableViaPrintTo: " <<
x.value;
143 const PointerPrintable* ) {
144 return os <<
"PointerPrintable*";
160 *os <<
"PrintableViaPrintToTemplate: " <<
x.value();
177 return os <<
"StreamableTemplateInFoo: " <<
x.value();
201 return os <<
"Streamable-PathLike";
208namespace gtest_printers_test {
212using ::std::make_pair;
214using ::std::multimap;
215using ::std::multiset;
219using ::testing::PrintToString;
220using ::testing::internal::FormatForComparisonFailureMessage;
221using ::testing::internal::ImplicitCast_;
222using ::testing::internal::NativeArray;
223using ::testing::internal::RelationToSourceReference;
224using ::testing::internal::Strings;
225using ::testing::internal::UniversalPrint;
226using ::testing::internal::UniversalPrinter;
227using ::testing::internal::UniversalTersePrint;
228using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
234 ::std::stringstream ss;
235 UniversalPrinter<T>::Print(
value, &ss);
244 ::std::stringstream ss;
245 UniversalPrinter<T&>::Print(
value, &ss);
280TEST(PrintCharTest, PlainChar) {
300TEST(PrintCharTest, SignedChar) {
303 Print(
static_cast<signed char>(-50)));
307TEST(PrintCharTest, UnsignedChar) {
310 Print(
static_cast<unsigned char>(
'b')));
322TEST(PrintCharTest, Char8) {
336TEST(PrintBuiltInTypeTest, Wchar_t) {
353 EXPECT_EQ(
"L'\\x576' (1398)",
Print(
static_cast<wchar_t>(0x576)));
354 EXPECT_EQ(
"L'\\xC74D' (51021)",
Print(
static_cast<wchar_t>(0xC74D)));
358TEST(PrintTypeSizeTest, Wchar_t) {
359 EXPECT_LT(
sizeof(
wchar_t),
sizeof(int64_t));
363TEST(PrintBuiltInTypeTest, Integer) {
364 EXPECT_EQ(
"'\\xFF' (255)",
Print(
static_cast<unsigned char>(255)));
365 EXPECT_EQ(
"'\\x80' (-128)",
Print(
static_cast<signed char>(-128)));
369 Print(std::numeric_limits<uint32_t>::max()));
371 Print(std::numeric_limits<int32_t>::min()));
373 Print(std::numeric_limits<uint64_t>::max()));
375 Print(std::numeric_limits<int64_t>::min()));
378 Print(std::numeric_limits<char8_t>::min()));
380 Print(std::numeric_limits<char8_t>::max()));
383 Print(std::numeric_limits<char16_t>::min()));
385 Print(std::numeric_limits<char16_t>::max()));
387 Print(std::numeric_limits<char32_t>::min()));
389 Print(std::numeric_limits<char32_t>::max()));
393TEST(PrintBuiltInTypeTest, Size_t) {
402TEST(PrintBuiltInTypeTest, FloatingPoints) {
411 ::std::stringstream expected_result_stream;
412 expected_result_stream <<
p;
413 return expected_result_stream.str();
420 const char*
p =
"World";
425TEST(PrintCStringTest, NonConst) {
428 Print(
static_cast<char*
>(
p)));
433 const char*
p =
nullptr;
438TEST(PrintCStringTest, EscapesProperly) {
439 const char*
p =
"'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
441 "\\n\\r\\t\\v\\x7F\\xFF a\"",
451#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
454TEST(PrintWideCStringTest, Const) {
455 const wchar_t*
p = L
"World";
460TEST(PrintWideCStringTest, NonConst) {
463 Print(
static_cast<wchar_t*
>(
p)));
467TEST(PrintWideCStringTest, Null) {
468 const wchar_t*
p =
nullptr;
473TEST(PrintWideCStringTest, EscapesProperly) {
474 const wchar_t s[] = {
'\'',
'"',
'?',
'\\',
'\a',
'\b',
'\f',
'\n',
'\r',
475 '\t',
'\v', 0xD3, 0x576, 0x8D3, 0xC74D,
' ',
'a',
'\0'};
477 "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
478 Print(
static_cast<const wchar_t*
>(s)));
485TEST(PrintCharPointerTest, SignedChar) {
486 signed char*
p =
reinterpret_cast<signed char*
>(0x1234);
493TEST(PrintCharPointerTest, ConstSignedChar) {
494 signed char*
p =
reinterpret_cast<signed char*
>(0x1234);
501TEST(PrintCharPointerTest, UnsignedChar) {
502 unsigned char*
p =
reinterpret_cast<unsigned char*
>(0x1234);
509TEST(PrintCharPointerTest, ConstUnsignedChar) {
510 const unsigned char*
p =
reinterpret_cast<const unsigned char*
>(0x1234);
518TEST(PrintCharPointerTest, Char8) {
519 char8_t*
p =
reinterpret_cast<char8_t*
>(0x1234);
526TEST(PrintCharPointerTest, ConstChar8) {
527 const char8_t*
p =
reinterpret_cast<const char8_t*
>(0x1234);
535TEST(PrintCharPointerTest, Char16) {
536 char16_t*
p =
reinterpret_cast<char16_t*
>(0x1234);
543TEST(PrintCharPointerTest, ConstChar16) {
544 const char16_t*
p =
reinterpret_cast<const char16_t*
>(0x1234);
551TEST(PrintCharPointerTest, Char32) {
552 char32_t*
p =
reinterpret_cast<char32_t*
>(0x1234);
559TEST(PrintCharPointerTest, ConstChar32) {
560 const char32_t*
p =
reinterpret_cast<const char32_t*
>(0x1234);
570 bool*
p =
reinterpret_cast<bool*
>(0xABCD);
578 void*
p =
reinterpret_cast<void*
>(0xABCD);
585TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
586 const void*
p =
reinterpret_cast<const void*
>(0xABCD);
593TEST(PrintPointerToPointerTest, IntPointerPointer) {
594 int**
p =
reinterpret_cast<int**
>(0xABCD);
604TEST(PrintPointerTest, NonMemberFunctionPointer) {
613 int (*
p)(bool) = NULL;
619template <
typename StringType>
620AssertionResult
HasPrefix(
const StringType& str,
const StringType& prefix) {
621 if (str.find(prefix, 0) == 0)
624 const bool is_wide_string =
sizeof(prefix[0]) > 1;
625 const char*
const begin_string_quote = is_wide_string ?
"L\"" :
"\"";
627 << begin_string_quote << prefix <<
"\" is not a prefix of "
628 << begin_string_quote << str <<
"\"\n";
645TEST(PrintPointerTest, MemberVariablePointer) {
650 Print(
sizeof(
p)) +
"-byte object "));
657TEST(PrintPointerTest, MemberFunctionPointer) {
663 int (
Foo::*
p)(char) = NULL;
665 Print(
sizeof(
p)) +
"-byte object "));
672template <
typename T,
size_t N>
678TEST(PrintArrayTest, OneDimensionalArray) {
679 int a[5] = { 1, 2, 3, 4, 5 };
684TEST(PrintArrayTest, TwoDimensionalArray) {
689 EXPECT_EQ(
"{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }",
PrintArrayHelper(
a));
693TEST(PrintArrayTest, ConstArray) {
694 const bool a[1] = {
false };
699TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
701 char a[] = {
'H',
'\0',
'i' };
706TEST(PrintArrayTest, ConstCharArrayWithTerminatingNul) {
707 const char a[] =
"\0Hi";
712TEST(PrintArrayTest, WCharArrayWithNoTerminatingNul) {
714 const wchar_t a[] = { L
'H', L
'\0', L
'i' };
719TEST(PrintArrayTest, WConstCharArrayWithTerminatingNul) {
720 const wchar_t a[] = L
"\0Hi";
726TEST(PrintArrayTest, Char8Array) {
727 const char8_t a[] = u8
"Hello, world!";
729 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+0077, "
730 "U+006F, U+0072, U+006C, U+0064, U+0021, U+0000 }",
736TEST(PrintArrayTest, Char16Array) {
737 const char16_t a[] = u
"Hello, 世界";
739 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+4E16, "
745TEST(PrintArrayTest, Char32Array) {
746 const char32_t a[] = U
"Hello, 世界";
748 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+4E16, "
754TEST(PrintArrayTest, ObjectArray) {
755 std::string
a[3] = {
"Hi",
"Hello",
"Ni hao"};
760TEST(PrintArrayTest, BigArray) {
761 int a[100] = { 1, 2, 3 };
762 EXPECT_EQ(
"{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
769TEST(PrintStringTest, StringInStdNamespace) {
770 const char s[] =
"'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
771 const ::std::string str(s,
sizeof(s));
772 EXPECT_EQ(
"\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
776TEST(PrintStringTest, StringAmbiguousHex) {
783 EXPECT_EQ(
"\"mm\\x6\" \"bananas\"",
Print(::std::string(
"mm\x6" "bananas")));
785 EXPECT_EQ(
"\"NOM\\x6\" \"BANANA\"",
Print(::std::string(
"NOM\x6" "BANANA")));
791#if GTEST_HAS_STD_WSTRING
793TEST(PrintWideStringTest, StringInStdNamespace) {
794 const wchar_t s[] = L
"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
795 const ::std::wstring str(s,
sizeof(s)/
sizeof(
wchar_t));
796 EXPECT_EQ(
"L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
797 "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
801TEST(PrintWideStringTest, StringAmbiguousHex) {
803 EXPECT_EQ(
"L\"0\\x12\" L\"3\"",
Print(::std::wstring(L
"0\x12" L
"3")));
805 Print(::std::wstring(L
"mm\x6" L
"bananas")));
807 Print(::std::wstring(L
"NOM\x6" L
"BANANA")));
813TEST(PrintStringTest, U8String) {
814 std::u8string str = u8
"Hello, world!";
817 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+0077, "
818 "U+006F, U+0072, U+006C, U+0064, U+0021 }",
823TEST(PrintStringTest, U16String) {
824 std::u16string str = u
"Hello, 世界";
827 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+4E16, "
832TEST(PrintStringTest, U32String) {
833 std::u32string str = U
"Hello, 世界";
836 "{ U+0048, U+0065, U+006C, U+006C, U+006F, U+002C, U+0020, U+4E16, "
849template <
typename Char,
typename CharTraits>
850std::basic_ostream<Char, CharTraits>&
operator<<(
851 std::basic_ostream<Char, CharTraits>& os,
853 return os <<
"AllowsGenericStreaming";
856TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
866template <
typename Char,
typename CharTraits,
typename T>
867std::basic_ostream<Char, CharTraits>&
operator<<(
868 std::basic_ostream<Char, CharTraits>& os,
870 return os <<
"AllowsGenericStreamingTemplate";
873TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
884 operator bool()
const {
return false; }
887template <
typename Char,
typename CharTraits,
typename T>
888std::basic_ostream<Char, CharTraits>&
operator<<(
889 std::basic_ostream<Char, CharTraits>& os,
890 const AllowsGenericStreamingAndImplicitConversionTemplate<T>& ) {
891 return os <<
"AllowsGenericStreamingAndImplicitConversionTemplate";
894TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
896 EXPECT_EQ(
"AllowsGenericStreamingAndImplicitConversionTemplate",
Print(
a));
899#if GTEST_INTERNAL_HAS_STRING_VIEW
903TEST(PrintStringViewTest, SimpleStringView) {
904 const internal::StringView sp =
"Hello";
908TEST(PrintStringViewTest, UnprintableCharacters) {
909 const char str[] =
"NUL (\0) and \r\t";
910 const internal::StringView sp(str,
sizeof(str) - 1);
918TEST(PrintStlContainerTest, EmptyDeque) {
923TEST(PrintStlContainerTest, NonEmptyDeque) {
924 deque<int> non_empty;
925 non_empty.push_back(1);
926 non_empty.push_back(3);
931TEST(PrintStlContainerTest, OneElementHashMap) {
932 ::std::unordered_map<int, char> map1;
937TEST(PrintStlContainerTest, HashMultiMap) {
938 ::std::unordered_multimap<int, bool> map1;
939 map1.insert(make_pair(5,
true));
940 map1.insert(make_pair(5,
false));
943 const std::string result =
Print(map1);
944 EXPECT_TRUE(result ==
"{ (5, true), (5, false) }" ||
945 result ==
"{ (5, false), (5, true) }")
946 <<
" where Print(map1) returns \"" << result <<
"\".";
951TEST(PrintStlContainerTest, HashSet) {
952 ::std::unordered_set<int> set1;
957TEST(PrintStlContainerTest, HashMultiSet) {
959 int a[kSize] = { 1, 1, 2, 5, 1 };
960 ::std::unordered_multiset<int> set1(
a,
a + kSize);
963 const std::string result =
Print(set1);
964 const std::string expected_pattern =
"{ d, d, d, d, d }";
968 ASSERT_EQ(expected_pattern.length(), result.length());
969 std::vector<int> numbers;
970 for (
size_t i = 0;
i != result.length();
i++) {
971 if (expected_pattern[
i] ==
'd') {
972 ASSERT_NE(isdigit(
static_cast<unsigned char>(result[
i])), 0);
973 numbers.push_back(result[
i] -
'0');
975 EXPECT_EQ(expected_pattern[
i], result[
i]) <<
" where result is "
981 std::sort(numbers.begin(), numbers.end());
982 std::sort(
a,
a + kSize);
987TEST(PrintStlContainerTest, List) {
988 const std::string
a[] = {
"hello",
"world"};
989 const list<std::string> strings(
a,
a + 2);
993TEST(PrintStlContainerTest, Map) {
1001TEST(PrintStlContainerTest, MultiMap) {
1002 multimap<bool, int> map1;
1009 map1.insert(pair<const bool, int>(
true, 0));
1010 map1.insert(pair<const bool, int>(
true, 1));
1011 map1.insert(pair<const bool, int>(
false, 2));
1016 const unsigned int a[] = { 3, 0, 5 };
1017 set<unsigned int> set1(
a,
a + 3);
1021TEST(PrintStlContainerTest, MultiSet) {
1022 const int a[] = { 1, 1, 2, 5, 1 };
1023 multiset<int> set1(
a,
a + 5);
1028TEST(PrintStlContainerTest, SinglyLinkedList) {
1029 int a[] = { 9, 2, 8 };
1030 const std::forward_list<int> ints(
a,
a + 3);
1035 pair<const bool, int>
p(
true, 5);
1039TEST(PrintStlContainerTest, Vector) {
1046TEST(PrintStlContainerTest, LongSequence) {
1047 const int a[100] = { 1, 2, 3 };
1048 const vector<int> v(
a,
a + 100);
1049 EXPECT_EQ(
"{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
1050 "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }",
Print(v));
1053TEST(PrintStlContainerTest, NestedContainer) {
1054 const int a1[] = { 1, 2 };
1055 const int a2[] = { 3, 4, 5 };
1056 const list<int> l1(a1, a1 + 2);
1057 const list<int> l2(a2, a2 + 3);
1059 vector<list<int> > v;
1065TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
1066 const int a[3] = { 1, 2, 3 };
1067 NativeArray<int> b(
a, 3, RelationToSourceReference());
1071TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
1072 const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
1073 NativeArray<int[3]> b(
a, 2, RelationToSourceReference());
1083TEST(PrintStlContainerTest, Iterator) {
1094TEST(PrintStlContainerTest, ConstIterator) {
1102TEST(PrintStdTupleTest, VariousSizes) {
1106 ::std::tuple<int> t1(5);
1109 ::std::tuple<char, bool> t2(
'a',
true);
1112 ::std::tuple<bool, int, int> t3(
false, 2, 3);
1115 ::std::tuple<bool, int, int, int> t4(
false, 2, 3, 4);
1118 const char*
const str =
"8";
1119 ::std::tuple<bool, char, short, int32_t, int64_t, float, double,
1120 const char*,
void*, std::string>
1121 t10(
false,
'a',
static_cast<short>(3), 4, 5, 1.5F, -2.5, str,
1124 " pointing to \"8\", NULL, \"10\")",
1129TEST(PrintStdTupleTest, NestedTuple) {
1130 ::std::tuple< ::std::tuple<int, bool>,
char> nested(
1131 ::std::make_tuple(5,
true),
'a');
1139TEST(PrintReferenceWrapper, Printable) {
1145TEST(PrintReferenceWrapper, Unprintable) {
1149 " 16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1150 Print(std::ref(up)));
1153 " 16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1154 Print(std::cref(up)));
1160TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
1166TEST(PrintUnprintableTypeTest, InUserNamespace) {
1167 EXPECT_EQ(
"16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1178TEST(PrintUnpritableTypeTest, BigObject) {
1179 EXPECT_EQ(
"257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
1180 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1181 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1182 "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
1183 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1184 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
1185 "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
1192TEST(PrintStreamableTypeTest, InGlobalNamespace) {
1199TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
1206TEST(PrintStreamableTypeTest, PathLikeInUserNamespace) {
1209 const ::foo::PathLike cx;
1214TEST(PrintPrintableTypeTest, InUserNamespace) {
1221TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
1227TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
1228 EXPECT_EQ(
"PrintableViaPrintToTemplate: 5",
1234TEST(PrintReferenceTest, PrintsAddressAndValue) {
1245 const ::foo::UnprintableInFoo
x;
1247 "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
1253TEST(PrintReferenceTest, HandlesFunctionPointer) {
1255 const std::string fp_pointer_string =
1261 const std::string fp_string =
PrintPointer(
reinterpret_cast<const void*
>(
1263 EXPECT_EQ(
"@" + fp_pointer_string +
" " + fp_string,
1269TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
1273 "@" +
PrintPointer(
reinterpret_cast<const void*
>(&
p)) +
" " +
1274 Print(
sizeof(
p)) +
"-byte object "));
1279 "@" +
PrintPointer(
reinterpret_cast<const void*
>(&p2)) +
" " +
1280 Print(
sizeof(p2)) +
"-byte object "));
1285TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
1297TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
1299 FormatForComparisonFailureMessage(123, 124).c_str());
1303TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
1306 FormatForComparisonFailureMessage(&n, &n).c_str());
1310TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer) {
1313 int n[] = { 1, 2, 3 };
1315 FormatForComparisonFailureMessage(n, n).c_str());
1323TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer) {
1330 const char* s =
"hello";
1332 FormatForComparisonFailureMessage(s, s).c_str());
1337 FormatForComparisonFailureMessage(&
ch, &
ch).c_str());
1341TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer) {
1348 const wchar_t* s = L
"hello";
1350 FormatForComparisonFailureMessage(s, s).c_str());
1355 FormatForComparisonFailureMessage(&
ch, &
ch).c_str());
1362TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsStdString) {
1363 const char* s =
"hello \"world";
1365 FormatForComparisonFailureMessage(s, ::std::string()).c_str());
1368 char str[] =
"hi\1";
1371 FormatForComparisonFailureMessage(
p, ::std::string()).c_str());
1374#if GTEST_HAS_STD_WSTRING
1376TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsStdWString) {
1377 const wchar_t* s = L
"hi \"world";
1379 FormatForComparisonFailureMessage(s, ::std::wstring()).c_str());
1382 wchar_t str[] = L
"hi\1";
1385 FormatForComparisonFailureMessage(
p, ::std::wstring()).c_str());
1394TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) {
1395 char str[] =
"hi \"world\"";
1398 FormatForComparisonFailureMessage(str,
p).c_str());
1402TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray) {
1403 const char str[] =
"hi \"world\"";
1405 FormatForComparisonFailureMessage(str, str).c_str());
1409TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) {
1410 wchar_t str[] = L
"hi \"world\"";
1411 wchar_t*
p =
nullptr;
1413 FormatForComparisonFailureMessage(str,
p).c_str());
1417TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCharArray) {
1418 const wchar_t str[] = L
"hi \"world\"";
1420 FormatForComparisonFailureMessage(str, str).c_str());
1427TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdString) {
1428 const char str[] =
"hi \"world\"";
1430 FormatForComparisonFailureMessage(str, ::std::string()).c_str());
1433#if GTEST_HAS_STD_WSTRING
1435TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
1436 const wchar_t str[] = L
"hi \"w\0rld\"";
1440 FormatForComparisonFailureMessage(str, ::std::wstring()).c_str());
1447#define EXPECT_PRINT_TO_STRING_(value, expected_string) \
1448 EXPECT_TRUE(PrintToString(value) == (expected_string)) \
1449 << " where " #value " prints as " << (PrintToString(value))
1451TEST(PrintToStringTest, WorksForScalar) {
1455TEST(PrintToStringTest, WorksForPointerToConstChar) {
1456 const char*
p =
"hello";
1460TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
1466TEST(PrintToStringTest, EscapesForPointerToConstChar) {
1467 const char*
p =
"hello\n";
1471TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
1472 char s[] =
"hello\1";
1477TEST(PrintToStringTest, WorksForArray) {
1478 int n[3] = { 1, 2, 3 };
1482TEST(PrintToStringTest, WorksForCharArray) {
1487TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
1488 const char str_with_nul[] =
"hello\0 world";
1491 char mutable_str_with_nul[] =
"hello\0 world";
1495 TEST(PrintToStringTest, ContainsNonLatin) {
1497 std::string non_ascii_str = ::std::string(
"ì˜¤ì „ 4:30");
1499 "\"\\xEC\\x98\\xA4\\xEC\\xA0\\x84 4:30\"\n"
1500 " As Text: \"ì˜¤ì „ 4:30\"");
1501 non_ascii_str = ::std::string(
"From ä — ẑ");
1503 "\"From \\xC3\\xA4 \\xE2\\x80\\x94 \\xE1\\xBA\\x91\""
1504 "\n As Text: \"From ä — ẑ\"");
1507TEST(IsValidUTF8Test, IllFormedUTF8) {
1512 static const char *
const kTestdata[][2] = {
1514 {
"\xC3\x74",
"\"\\xC3t\""},
1516 {
"\xC3\x84\xA4",
"\"\\xC3\\x84\\xA4\""},
1518 {
"abc\xC3",
"\"abc\\xC3\""},
1520 {
"x\xE2\x70\x94",
"\"x\\xE2p\\x94\""},
1522 {
"\xE2\x80",
"\"\\xE2\\x80\""},
1524 {
"\xE2\x80\xC3\x84",
"\"\\xE2\\x80\\xC3\\x84\""},
1526 {
"\xE2\x80\x7A",
"\"\\xE2\\x80z\""},
1528 {
"\xE2\xE2\x80\x94",
"\"\\xE2\\xE2\\x80\\x94\""},
1530 {
"\xF0\xE2\x80\x94",
"\"\\xF0\\xE2\\x80\\x94\""},
1532 {
"\xF0\xE2\x80",
"\"\\xF0\\xE2\\x80\""},
1534 {
"abc\xE2\x80\x94\xC3\x74xyc",
"\"abc\\xE2\\x80\\x94\\xC3txyc\""},
1535 {
"abc\xC3\x84\xE2\x80\xC3\x84xyz",
1536 "\"abc\\xC3\\x84\\xE2\\x80\\xC3\\x84xyz\""},
1539 {
"\xC0\x80",
"\"\\xC0\\x80\""},
1540 {
"\xC1\x81",
"\"\\xC1\\x81\""},
1542 {
"\xE0\x80\x80",
"\"\\xE0\\x80\\x80\""},
1543 {
"\xf0\x80\x80\x80",
"\"\\xF0\\x80\\x80\\x80\""},
1546 {
"\xED\x9F\xBF",
"\"\\xED\\x9F\\xBF\"\n As Text: \"퟿\""},
1548 {
"\xED\xA0\x80",
"\"\\xED\\xA0\\x80\""},
1550 {
"\xED\xAD\xBF",
"\"\\xED\\xAD\\xBF\""},
1552 {
"\xED\xAE\x80",
"\"\\xED\\xAE\\x80\""},
1554 {
"\xED\xAF\xBF",
"\"\\xED\\xAF\\xBF\""},
1556 {
"\xED\xB3\xBF",
"\"\\xED\\xB3\\xBF\""},
1559 {
"\xEE\x80\x80",
"\"\\xEE\\x80\\x80\"\n As Text: \"\""}
1562 for (
int i = 0;
i < int(
sizeof(kTestdata)/
sizeof(kTestdata[0])); ++
i) {
1567#undef EXPECT_PRINT_TO_STRING_
1569TEST(UniversalTersePrintTest, WorksForNonReference) {
1570 ::std::stringstream ss;
1571 UniversalTersePrint(123, &ss);
1575TEST(UniversalTersePrintTest, WorksForReference) {
1577 ::std::stringstream ss;
1578 UniversalTersePrint(n, &ss);
1582TEST(UniversalTersePrintTest, WorksForCString) {
1583 const char* s1 =
"abc";
1584 ::std::stringstream ss1;
1585 UniversalTersePrint(s1, &ss1);
1588 char* s2 =
const_cast<char*
>(s1);
1589 ::std::stringstream ss2;
1590 UniversalTersePrint(s2, &ss2);
1593 const char* s3 =
nullptr;
1594 ::std::stringstream ss3;
1595 UniversalTersePrint(s3, &ss3);
1599TEST(UniversalPrintTest, WorksForNonReference) {
1600 ::std::stringstream ss;
1601 UniversalPrint(123, &ss);
1605TEST(UniversalPrintTest, WorksForReference) {
1607 ::std::stringstream ss;
1608 UniversalPrint(n, &ss);
1612TEST(UniversalPrintTest, WorksForCString) {
1613 const char* s1 =
"abc";
1614 ::std::stringstream ss1;
1615 UniversalPrint(s1, &ss1);
1618 char* s2 =
const_cast<char*
>(s1);
1619 ::std::stringstream ss2;
1620 UniversalPrint(s2, &ss2);
1623 const char* s3 =
nullptr;
1624 ::std::stringstream ss3;
1625 UniversalPrint(s3, &ss3);
1629TEST(UniversalPrintTest, WorksForCharArray) {
1630 const char str[] =
"\"Line\0 1\"\nLine 2";
1631 ::std::stringstream ss1;
1632 UniversalPrint(str, &ss1);
1633 EXPECT_EQ(
"\"\\\"Line\\0 1\\\"\\nLine 2\"", ss1.str());
1635 const char mutable_str[] =
"\"Line\0 1\"\nLine 2";
1636 ::std::stringstream ss2;
1637 UniversalPrint(mutable_str, &ss2);
1638 EXPECT_EQ(
"\"\\\"Line\\0 1\\\"\\nLine 2\"", ss2.str());
1641TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
1642 Strings result = UniversalTersePrintTupleFieldsToStrings(::std::make_tuple());
1646TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple) {
1647 Strings result = UniversalTersePrintTupleFieldsToStrings(
1648 ::std::make_tuple(1));
1653TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple) {
1654 Strings result = UniversalTersePrintTupleFieldsToStrings(
1655 ::std::make_tuple(1,
'a'));
1661TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely) {
1663 Strings result = UniversalTersePrintTupleFieldsToStrings(
1664 ::std::tuple<const int&, const char*>(n,
"a"));
1670#if GTEST_INTERNAL_HAS_ANY
1673 template <
typename T>
1674 static std::string ExpectedTypeName() {
1676 return internal::GetTypeName<T>();
1678 return "<unknown_type>";
1683TEST_F(PrintAnyTest, Empty) {
1688TEST_F(PrintAnyTest, NonEmpty) {
1690 constexpr int val1 = 10;
1691 const std::string val2 =
"content";
1697 EXPECT_EQ(
"value of type " + ExpectedTypeName<std::string>(),
1702#if GTEST_INTERNAL_HAS_OPTIONAL
1703TEST(PrintOptionalTest, Basic) {
1704 internal::Optional<int>
value;
1713#if GTEST_INTERNAL_HAS_VARIANT
1714struct NonPrintable {
1715 unsigned char contents = 17;
1718TEST(PrintOneofTest, Basic) {
1719 using Type = internal::Variant<int, StreamableInGlobal, NonPrintable>;
1721 EXPECT_EQ(
"('StreamableInGlobal(index = 1)' with value StreamableInGlobal)",
1724 "('testing::gtest_printers_test::NonPrintable(index = 2)' with value "
1725 "1-byte object <11>)",
1737 string_ptr(
const char* data,
size_t size) :
data_(data),
size_(size) {}
1739 string_ptr& operator++() noexcept {
1756 string_ref(
const char* data,
size_t size) :
data_(data),
size_(size) {}
1758 string_ptr operator&()
const noexcept {
return {
data_,
size_}; }
1760 bool operator==(
const char* s)
const noexcept {
1762 return std::string(
data_,
size_) == std::string(s);
1764 return std::string(
data_) == std::string(s);
1773string_ref string_ptr::operator*() const noexcept {
return {
data_,
size_}; }
1775TEST(string_ref, compare) {
1776 const char* s =
"alex\0davidjohn\0";
1777 string_ptr ptr(s, 5);
virtual ~StreamableInGlobal()
UnprintableTemplateInGlobal()
friend::std::ostream & operator<<(::std::ostream &os, const PathLike &)
PrintableViaPrintToTemplate(const T &a_value)
StreamableTemplateInFoo()
std::ostream & operator<<(std::ostream &os, EnumWithStreaming e)
#define EXPECT_PRINT_TO_STRING_(value, expected_string)
void PrintTo(EnumWithPrintTo e, std::ostream *os)
#define TEST_F(test_fixture, test_name)
#define ASSERT_EQ(val1, val2)
#define EXPECT_EQ(val1, val2)
#define ASSERT_NE(val1, val2)
#define TEST(test_suite_name, test_name)
#define EXPECT_TRUE(condition)
#define EXPECT_STREQ(s1, s2)
#define EXPECT_LT(val1, val2)
SimpleFad< ValueT > operator*(const SimpleFad< ValueT > &a, const SimpleFad< ValueT > &b)
::std::ostream & operator<<(::std::ostream &os, const PointerPrintable *)
void PrintTo(const PrintableViaPrintTo &x, ::std::ostream *os)
std::basic_ostream< Char, CharTraits > & operator<<(std::basic_ostream< Char, CharTraits > &os, const AllowsGenericStreaming &)
std::string PrintByRef(const T &value)
std::string PrintArrayHelper(T(&a)[N])
std::string Print(const T &value)
AssertionResult HasPrefix(const StringType &str, const StringType &prefix)
static std::string PrintPointer(const void *p)
AssertionResult AssertionFailure()
::std::string PrintToString(const T &value)
AssertionResult AssertionSuccess()
virtual char MyVirtualMethod(int)