1 // Copyright 2007, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
30 // Author: wan@google.com (Zhanyong Wan)
32 // Google Test - The Google C++ Testing Framework
34 // This file implements a universal value printer that can print a
35 // value of any type T:
37 // void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
39 // It uses the << operator when possible, and prints the bytes in the
40 // object otherwise. A user can override its behavior for a class
41 // type Foo by defining either operator<<(::std::ostream&, const Foo&)
42 // or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
45 #include "gtest/gtest-printers.h"
48 #include <ostream> // NOLINT
50 #include "gtest/internal/gtest-port.h"
58 // Prints a segment of bytes in the given object.
59 void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes
, size_t start
,
60 size_t count
, ostream
* os
) {
62 for (size_t i
= 0; i
!= count
; i
++) {
63 const size_t j
= start
+ i
;
65 // Organizes the bytes into groups of 2 for easy parsing by
72 GTEST_SNPRINTF_(text
, sizeof(text
), "%02X", obj_bytes
[j
]);
77 // Prints the bytes in the given value to the given ostream.
78 void PrintBytesInObjectToImpl(const unsigned char* obj_bytes
, size_t count
,
80 // Tells the user how big the object is.
81 *os
<< count
<< "-byte object <";
83 const size_t kThreshold
= 132;
84 const size_t kChunkSize
= 64;
85 // If the object size is bigger than kThreshold, we'll have to omit
86 // some details by printing only the first and the last kChunkSize
88 // TODO(wan): let the user control the threshold using a flag.
89 if (count
< kThreshold
) {
90 PrintByteSegmentInObjectTo(obj_bytes
, 0, count
, os
);
92 PrintByteSegmentInObjectTo(obj_bytes
, 0, kChunkSize
, os
);
94 // Rounds up to 2-byte boundary.
95 const size_t resume_pos
= (count
- kChunkSize
+ 1)/2*2;
96 PrintByteSegmentInObjectTo(obj_bytes
, resume_pos
, count
- resume_pos
, os
);
103 namespace internal2
{
105 // Delegates to PrintBytesInObjectToImpl() to print the bytes in the
106 // given object. The delegation simplifies the implementation, which
107 // uses the << operator and thus is easier done outside of the
108 // ::testing::internal namespace, which contains a << operator that
109 // sometimes conflicts with the one in STL.
110 void PrintBytesInObjectTo(const unsigned char* obj_bytes
, size_t count
,
112 PrintBytesInObjectToImpl(obj_bytes
, count
, os
);
115 } // namespace internal2
119 // Depending on the value of a char (or wchar_t), we print it in one
121 // - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
122 // - as a hexidecimal escape sequence (e.g. '\x7F'), or
123 // - as a special escape sequence (e.g. '\r', '\n').
130 // Returns true if c is a printable ASCII character. We test the
131 // value of c directly instead of calling isprint(), which is buggy on
133 inline bool IsPrintableAscii(wchar_t c
) {
134 return 0x20 <= c
&& c
<= 0x7E;
137 // Prints a wide or narrow char c as a character literal without the
138 // quotes, escaping it when necessary; returns how c was formatted.
139 // The template argument UnsignedChar is the unsigned version of Char,
140 // which is the type of c.
141 template <typename UnsignedChar
, typename Char
>
142 static CharFormat
PrintAsCharLiteralTo(Char c
, ostream
* os
) {
143 switch (static_cast<wchar_t>(c
)) {
175 if (IsPrintableAscii(c
)) {
176 *os
<< static_cast<char>(c
);
179 *os
<< String::Format("\\x%X", static_cast<UnsignedChar
>(c
));
183 return kSpecialEscape
;
186 // Prints a wchar_t c as if it's part of a string literal, escaping it when
187 // necessary; returns how c was formatted.
188 static CharFormat
PrintAsStringLiteralTo(wchar_t c
, ostream
* os
) {
195 return kSpecialEscape
;
197 return PrintAsCharLiteralTo
<wchar_t>(c
, os
);
201 // Prints a char c as if it's part of a string literal, escaping it when
202 // necessary; returns how c was formatted.
203 static CharFormat
PrintAsStringLiteralTo(char c
, ostream
* os
) {
204 return PrintAsStringLiteralTo(
205 static_cast<wchar_t>(static_cast<unsigned char>(c
)), os
);
208 // Prints a wide or narrow character c and its code. '\0' is printed
209 // as "'\\0'", other unprintable characters are also properly escaped
210 // using the standard C++ escape sequence. The template argument
211 // UnsignedChar is the unsigned version of Char, which is the type of c.
212 template <typename UnsignedChar
, typename Char
>
213 void PrintCharAndCodeTo(Char c
, ostream
* os
) {
214 // First, print c as a literal in the most readable form we can find.
215 *os
<< ((sizeof(c
) > 1) ? "L'" : "'");
216 const CharFormat format
= PrintAsCharLiteralTo
<UnsignedChar
>(c
, os
);
219 // To aid user debugging, we also print c's code in decimal, unless
220 // it's 0 (in which case c was printed as '\\0', making the code
224 *os
<< " (" << String::Format("%d", c
).c_str();
226 // For more convenience, we print c's code again in hexidecimal,
227 // unless c was already printed in the form '\x##' or the code is in
229 if (format
== kHexEscape
|| (1 <= c
&& c
<= 9)) {
232 *os
<< String::Format(", 0x%X",
233 static_cast<UnsignedChar
>(c
)).c_str();
238 void PrintTo(unsigned char c
, ::std::ostream
* os
) {
239 PrintCharAndCodeTo
<unsigned char>(c
, os
);
241 void PrintTo(signed char c
, ::std::ostream
* os
) {
242 PrintCharAndCodeTo
<unsigned char>(c
, os
);
245 // Prints a wchar_t as a symbol if it is printable or as its internal
246 // code otherwise and also as its code. L'\0' is printed as "L'\\0'".
247 void PrintTo(wchar_t wc
, ostream
* os
) {
248 PrintCharAndCodeTo
<wchar_t>(wc
, os
);
251 // Prints the given array of characters to the ostream. CharType must be either
253 // The array starts at begin, the length is len, it may include '\0' characters
254 // and may not be NUL-terminated.
255 template <typename CharType
>
256 static void PrintCharsAsStringTo(
257 const CharType
* begin
, size_t len
, ostream
* os
) {
258 const char* const kQuoteBegin
= sizeof(CharType
) == 1 ? "\"" : "L\"";
260 bool is_previous_hex
= false;
261 for (size_t index
= 0; index
< len
; ++index
) {
262 const CharType cur
= begin
[index
];
263 if (is_previous_hex
&& IsXDigit(cur
)) {
264 // Previous character is of '\x..' form and this character can be
265 // interpreted as another hexadecimal digit in its number. Break string to
267 *os
<< "\" " << kQuoteBegin
;
269 is_previous_hex
= PrintAsStringLiteralTo(cur
, os
) == kHexEscape
;
274 // Prints a (const) char/wchar_t array of 'len' elements, starting at address
275 // 'begin'. CharType must be either char or wchar_t.
276 template <typename CharType
>
277 static void UniversalPrintCharArray(
278 const CharType
* begin
, size_t len
, ostream
* os
) {
280 // const char kFoo[] = "foo";
281 // generates an array of 4, not 3, elements, with the last one being '\0'.
283 // Therefore when printing a char array, we don't print the last element if
284 // it's '\0', such that the output matches the string literal as it's
285 // written in the source code.
286 if (len
> 0 && begin
[len
- 1] == '\0') {
287 PrintCharsAsStringTo(begin
, len
- 1, os
);
291 // If, however, the last element in the array is not '\0', e.g.
292 // const char kFoo[] = { 'f', 'o', 'o' };
293 // we must print the entire array. We also print a message to indicate
294 // that the array is not NUL-terminated.
295 PrintCharsAsStringTo(begin
, len
, os
);
296 *os
<< " (no terminating NUL)";
299 // Prints a (const) char array of 'len' elements, starting at address 'begin'.
300 void UniversalPrintArray(const char* begin
, size_t len
, ostream
* os
) {
301 UniversalPrintCharArray(begin
, len
, os
);
304 // Prints a (const) wchar_t array of 'len' elements, starting at address
306 void UniversalPrintArray(const wchar_t* begin
, size_t len
, ostream
* os
) {
307 UniversalPrintCharArray(begin
, len
, os
);
310 // Prints the given C string to the ostream.
311 void PrintTo(const char* s
, ostream
* os
) {
315 *os
<< ImplicitCast_
<const void*>(s
) << " pointing to ";
316 PrintCharsAsStringTo(s
, strlen(s
), os
);
320 // MSVC compiler can be configured to define whar_t as a typedef
321 // of unsigned short. Defining an overload for const wchar_t* in that case
322 // would cause pointers to unsigned shorts be printed as wide strings,
323 // possibly accessing more memory than intended and causing invalid
324 // memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
325 // wchar_t is implemented as a native type.
326 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
327 // Prints the given wide C string to the ostream.
328 void PrintTo(const wchar_t* s
, ostream
* os
) {
332 *os
<< ImplicitCast_
<const void*>(s
) << " pointing to ";
333 PrintCharsAsStringTo(s
, wcslen(s
), os
);
336 #endif // wchar_t is native
338 // Prints a ::string object.
339 #if GTEST_HAS_GLOBAL_STRING
340 void PrintStringTo(const ::string
& s
, ostream
* os
) {
341 PrintCharsAsStringTo(s
.data(), s
.size(), os
);
343 #endif // GTEST_HAS_GLOBAL_STRING
345 void PrintStringTo(const ::std::string
& s
, ostream
* os
) {
346 PrintCharsAsStringTo(s
.data(), s
.size(), os
);
349 // Prints a ::wstring object.
350 #if GTEST_HAS_GLOBAL_WSTRING
351 void PrintWideStringTo(const ::wstring
& s
, ostream
* os
) {
352 PrintCharsAsStringTo(s
.data(), s
.size(), os
);
354 #endif // GTEST_HAS_GLOBAL_WSTRING
356 #if GTEST_HAS_STD_WSTRING
357 void PrintWideStringTo(const ::std::wstring
& s
, ostream
* os
) {
358 PrintCharsAsStringTo(s
.data(), s
.size(), os
);
360 #endif // GTEST_HAS_STD_WSTRING
362 } // namespace internal
364 } // namespace testing