gtest-printers.cc (14711B)
1 // Copyright 2007, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 31 // Google Test - The Google C++ Testing and Mocking Framework 32 // 33 // This file implements a universal value printer that can print a 34 // value of any type T: 35 // 36 // void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); 37 // 38 // It uses the << operator when possible, and prints the bytes in the 39 // object otherwise. A user can override its behavior for a class 40 // type Foo by defining either operator<<(::std::ostream&, const Foo&) 41 // or void PrintTo(const Foo&, ::std::ostream*) in the namespace that 42 // defines Foo. 43 44 #include "gtest/gtest-printers.h" 45 #include <stdio.h> 46 #include <cctype> 47 #include <cwchar> 48 #include <ostream> // NOLINT 49 #include <string> 50 #include "gtest/internal/gtest-port.h" 51 #include "src/gtest-internal-inl.h" 52 53 namespace testing { 54 55 namespace { 56 57 using ::std::ostream; 58 59 // Prints a segment of bytes in the given object. 60 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 61 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 62 GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 63 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 64 void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start, 65 size_t count, ostream* os) { 66 char text[5] = ""; 67 for (size_t i = 0; i != count; i++) { 68 const size_t j = start + i; 69 if (i != 0) { 70 // Organizes the bytes into groups of 2 for easy parsing by 71 // human. 72 if ((j % 2) == 0) 73 *os << ' '; 74 else 75 *os << '-'; 76 } 77 GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]); 78 *os << text; 79 } 80 } 81 82 // Prints the bytes in the given value to the given ostream. 83 void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count, 84 ostream* os) { 85 // Tells the user how big the object is. 86 *os << count << "-byte object <"; 87 88 const size_t kThreshold = 132; 89 const size_t kChunkSize = 64; 90 // If the object size is bigger than kThreshold, we'll have to omit 91 // some details by printing only the first and the last kChunkSize 92 // bytes. 93 if (count < kThreshold) { 94 PrintByteSegmentInObjectTo(obj_bytes, 0, count, os); 95 } else { 96 PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os); 97 *os << " ... "; 98 // Rounds up to 2-byte boundary. 99 const size_t resume_pos = (count - kChunkSize + 1)/2*2; 100 PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os); 101 } 102 *os << ">"; 103 } 104 105 } // namespace 106 107 namespace internal2 { 108 109 // Delegates to PrintBytesInObjectToImpl() to print the bytes in the 110 // given object. The delegation simplifies the implementation, which 111 // uses the << operator and thus is easier done outside of the 112 // ::testing::internal namespace, which contains a << operator that 113 // sometimes conflicts with the one in STL. 114 void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, 115 ostream* os) { 116 PrintBytesInObjectToImpl(obj_bytes, count, os); 117 } 118 119 } // namespace internal2 120 121 namespace internal { 122 123 // Depending on the value of a char (or wchar_t), we print it in one 124 // of three formats: 125 // - as is if it's a printable ASCII (e.g. 'a', '2', ' '), 126 // - as a hexadecimal escape sequence (e.g. '\x7F'), or 127 // - as a special escape sequence (e.g. '\r', '\n'). 128 enum CharFormat { 129 kAsIs, 130 kHexEscape, 131 kSpecialEscape 132 }; 133 134 // Returns true if c is a printable ASCII character. We test the 135 // value of c directly instead of calling isprint(), which is buggy on 136 // Windows Mobile. 137 inline bool IsPrintableAscii(wchar_t c) { 138 return 0x20 <= c && c <= 0x7E; 139 } 140 141 // Prints a wide or narrow char c as a character literal without the 142 // quotes, escaping it when necessary; returns how c was formatted. 143 // The template argument UnsignedChar is the unsigned version of Char, 144 // which is the type of c. 145 template <typename UnsignedChar, typename Char> 146 static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) { 147 wchar_t w_c = static_cast<wchar_t>(c); 148 switch (w_c) { 149 case L'\0': 150 *os << "\\0"; 151 break; 152 case L'\'': 153 *os << "\\'"; 154 break; 155 case L'\\': 156 *os << "\\\\"; 157 break; 158 case L'\a': 159 *os << "\\a"; 160 break; 161 case L'\b': 162 *os << "\\b"; 163 break; 164 case L'\f': 165 *os << "\\f"; 166 break; 167 case L'\n': 168 *os << "\\n"; 169 break; 170 case L'\r': 171 *os << "\\r"; 172 break; 173 case L'\t': 174 *os << "\\t"; 175 break; 176 case L'\v': 177 *os << "\\v"; 178 break; 179 default: 180 if (IsPrintableAscii(w_c)) { 181 *os << static_cast<char>(c); 182 return kAsIs; 183 } else { 184 ostream::fmtflags flags = os->flags(); 185 *os << "\\x" << std::hex << std::uppercase 186 << static_cast<int>(static_cast<UnsignedChar>(c)); 187 os->flags(flags); 188 return kHexEscape; 189 } 190 } 191 return kSpecialEscape; 192 } 193 194 // Prints a wchar_t c as if it's part of a string literal, escaping it when 195 // necessary; returns how c was formatted. 196 static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) { 197 switch (c) { 198 case L'\'': 199 *os << "'"; 200 return kAsIs; 201 case L'"': 202 *os << "\\\""; 203 return kSpecialEscape; 204 default: 205 return PrintAsCharLiteralTo<wchar_t>(c, os); 206 } 207 } 208 209 // Prints a char c as if it's part of a string literal, escaping it when 210 // necessary; returns how c was formatted. 211 static CharFormat PrintAsStringLiteralTo(char c, ostream* os) { 212 return PrintAsStringLiteralTo( 213 static_cast<wchar_t>(static_cast<unsigned char>(c)), os); 214 } 215 216 // Prints a wide or narrow character c and its code. '\0' is printed 217 // as "'\\0'", other unprintable characters are also properly escaped 218 // using the standard C++ escape sequence. The template argument 219 // UnsignedChar is the unsigned version of Char, which is the type of c. 220 template <typename UnsignedChar, typename Char> 221 void PrintCharAndCodeTo(Char c, ostream* os) { 222 // First, print c as a literal in the most readable form we can find. 223 *os << ((sizeof(c) > 1) ? "L'" : "'"); 224 const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os); 225 *os << "'"; 226 227 // To aid user debugging, we also print c's code in decimal, unless 228 // it's 0 (in which case c was printed as '\\0', making the code 229 // obvious). 230 if (c == 0) 231 return; 232 *os << " (" << static_cast<int>(c); 233 234 // For more convenience, we print c's code again in hexadecimal, 235 // unless c was already printed in the form '\x##' or the code is in 236 // [1, 9]. 237 if (format == kHexEscape || (1 <= c && c <= 9)) { 238 // Do nothing. 239 } else { 240 *os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); 241 } 242 *os << ")"; 243 } 244 245 void PrintTo(unsigned char c, ::std::ostream* os) { 246 PrintCharAndCodeTo<unsigned char>(c, os); 247 } 248 void PrintTo(signed char c, ::std::ostream* os) { 249 PrintCharAndCodeTo<unsigned char>(c, os); 250 } 251 252 // Prints a wchar_t as a symbol if it is printable or as its internal 253 // code otherwise and also as its code. L'\0' is printed as "L'\\0'". 254 void PrintTo(wchar_t wc, ostream* os) { 255 PrintCharAndCodeTo<wchar_t>(wc, os); 256 } 257 258 // Prints the given array of characters to the ostream. CharType must be either 259 // char or wchar_t. 260 // The array starts at begin, the length is len, it may include '\0' characters 261 // and may not be NUL-terminated. 262 template <typename CharType> 263 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 264 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 265 GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 266 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 267 static CharFormat PrintCharsAsStringTo( 268 const CharType* begin, size_t len, ostream* os) { 269 const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\""; 270 *os << kQuoteBegin; 271 bool is_previous_hex = false; 272 CharFormat print_format = kAsIs; 273 for (size_t index = 0; index < len; ++index) { 274 const CharType cur = begin[index]; 275 if (is_previous_hex && IsXDigit(cur)) { 276 // Previous character is of '\x..' form and this character can be 277 // interpreted as another hexadecimal digit in its number. Break string to 278 // disambiguate. 279 *os << "\" " << kQuoteBegin; 280 } 281 is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape; 282 // Remember if any characters required hex escaping. 283 if (is_previous_hex) { 284 print_format = kHexEscape; 285 } 286 } 287 *os << "\""; 288 return print_format; 289 } 290 291 // Prints a (const) char/wchar_t array of 'len' elements, starting at address 292 // 'begin'. CharType must be either char or wchar_t. 293 template <typename CharType> 294 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 295 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 296 GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 297 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 298 static void UniversalPrintCharArray( 299 const CharType* begin, size_t len, ostream* os) { 300 // The code 301 // const char kFoo[] = "foo"; 302 // generates an array of 4, not 3, elements, with the last one being '\0'. 303 // 304 // Therefore when printing a char array, we don't print the last element if 305 // it's '\0', such that the output matches the string literal as it's 306 // written in the source code. 307 if (len > 0 && begin[len - 1] == '\0') { 308 PrintCharsAsStringTo(begin, len - 1, os); 309 return; 310 } 311 312 // If, however, the last element in the array is not '\0', e.g. 313 // const char kFoo[] = { 'f', 'o', 'o' }; 314 // we must print the entire array. We also print a message to indicate 315 // that the array is not NUL-terminated. 316 PrintCharsAsStringTo(begin, len, os); 317 *os << " (no terminating NUL)"; 318 } 319 320 // Prints a (const) char array of 'len' elements, starting at address 'begin'. 321 void UniversalPrintArray(const char* begin, size_t len, ostream* os) { 322 UniversalPrintCharArray(begin, len, os); 323 } 324 325 // Prints a (const) wchar_t array of 'len' elements, starting at address 326 // 'begin'. 327 void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) { 328 UniversalPrintCharArray(begin, len, os); 329 } 330 331 // Prints the given C string to the ostream. 332 void PrintTo(const char* s, ostream* os) { 333 if (s == nullptr) { 334 *os << "NULL"; 335 } else { 336 *os << ImplicitCast_<const void*>(s) << " pointing to "; 337 PrintCharsAsStringTo(s, strlen(s), os); 338 } 339 } 340 341 // MSVC compiler can be configured to define whar_t as a typedef 342 // of unsigned short. Defining an overload for const wchar_t* in that case 343 // would cause pointers to unsigned shorts be printed as wide strings, 344 // possibly accessing more memory than intended and causing invalid 345 // memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when 346 // wchar_t is implemented as a native type. 347 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) 348 // Prints the given wide C string to the ostream. 349 void PrintTo(const wchar_t* s, ostream* os) { 350 if (s == nullptr) { 351 *os << "NULL"; 352 } else { 353 *os << ImplicitCast_<const void*>(s) << " pointing to "; 354 PrintCharsAsStringTo(s, wcslen(s), os); 355 } 356 } 357 #endif // wchar_t is native 358 359 namespace { 360 361 bool ContainsUnprintableControlCodes(const char* str, size_t length) { 362 const unsigned char *s = reinterpret_cast<const unsigned char *>(str); 363 364 for (size_t i = 0; i < length; i++) { 365 unsigned char ch = *s++; 366 if (std::iscntrl(ch)) { 367 switch (ch) { 368 case '\t': 369 case '\n': 370 case '\r': 371 break; 372 default: 373 return true; 374 } 375 } 376 } 377 return false; 378 } 379 380 bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; } 381 382 bool IsValidUTF8(const char* str, size_t length) { 383 const unsigned char *s = reinterpret_cast<const unsigned char *>(str); 384 385 for (size_t i = 0; i < length;) { 386 unsigned char lead = s[i++]; 387 388 if (lead <= 0x7f) { 389 continue; // single-byte character (ASCII) 0..7F 390 } 391 if (lead < 0xc2) { 392 return false; // trail byte or non-shortest form 393 } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) { 394 ++i; // 2-byte character 395 } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length && 396 IsUTF8TrailByte(s[i]) && 397 IsUTF8TrailByte(s[i + 1]) && 398 // check for non-shortest form and surrogate 399 (lead != 0xe0 || s[i] >= 0xa0) && 400 (lead != 0xed || s[i] < 0xa0)) { 401 i += 2; // 3-byte character 402 } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length && 403 IsUTF8TrailByte(s[i]) && 404 IsUTF8TrailByte(s[i + 1]) && 405 IsUTF8TrailByte(s[i + 2]) && 406 // check for non-shortest form 407 (lead != 0xf0 || s[i] >= 0x90) && 408 (lead != 0xf4 || s[i] < 0x90)) { 409 i += 3; // 4-byte character 410 } else { 411 return false; 412 } 413 } 414 return true; 415 } 416 417 void ConditionalPrintAsText(const char* str, size_t length, ostream* os) { 418 if (!ContainsUnprintableControlCodes(str, length) && 419 IsValidUTF8(str, length)) { 420 *os << "\n As Text: \"" << str << "\""; 421 } 422 } 423 424 } // anonymous namespace 425 426 void PrintStringTo(const ::std::string& s, ostream* os) { 427 if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) { 428 if (GTEST_FLAG(print_utf8)) { 429 ConditionalPrintAsText(s.data(), s.size(), os); 430 } 431 } 432 } 433 434 #if GTEST_HAS_STD_WSTRING 435 void PrintWideStringTo(const ::std::wstring& s, ostream* os) { 436 PrintCharsAsStringTo(s.data(), s.size(), os); 437 } 438 #endif // GTEST_HAS_STD_WSTRING 439 440 } // namespace internal 441 442 } // namespace testing