1 // Copyright 2005, 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 // Author: wan (at) google.com (Zhanyong Wan) 31 // 32 // The Google C++ Testing Framework (Google Test) 33 // 34 // This header file defines the Message class. 35 // 36 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to 37 // leave some internal implementation details in this header file. 38 // They are clearly marked by comments like this: 39 // 40 // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 41 // 42 // Such code is NOT meant to be used by a user directly, and is subject 43 // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user 44 // program! 45 46 #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 47 #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 48 49 #include <gtest/internal/gtest-string.h> 50 #include <gtest/internal/gtest-internal.h> 51 52 namespace testing { 53 54 // The Message class works like an ostream repeater. 55 // 56 // Typical usage: 57 // 58 // 1. You stream a bunch of values to a Message object. 59 // It will remember the text in a StrStream. 60 // 2. Then you stream the Message object to an ostream. 61 // This causes the text in the Message to be streamed 62 // to the ostream. 63 // 64 // For example; 65 // 66 // testing::Message foo; 67 // foo << 1 << " != " << 2; 68 // std::cout << foo; 69 // 70 // will print "1 != 2". 71 // 72 // Message is not intended to be inherited from. In particular, its 73 // destructor is not virtual. 74 // 75 // Note that StrStream behaves differently in gcc and in MSVC. You 76 // can stream a NULL char pointer to it in the former, but not in the 77 // latter (it causes an access violation if you do). The Message 78 // class hides this difference by treating a NULL char pointer as 79 // "(null)". 80 class Message { 81 private: 82 // The type of basic IO manipulators (endl, ends, and flush) for 83 // narrow streams. 84 typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); 85 86 public: 87 // Constructs an empty Message. 88 // We allocate the StrStream separately because it otherwise each use of 89 // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's 90 // stack frame leading to huge stack frames in some cases; gcc does not reuse 91 // the stack space. 92 Message() : ss_(new internal::StrStream) {} 93 94 // Copy constructor. 95 Message(const Message& msg) : ss_(new internal::StrStream) { // NOLINT 96 *ss_ << msg.GetString(); 97 } 98 99 // Constructs a Message from a C-string. 100 explicit Message(const char* str) : ss_(new internal::StrStream) { 101 *ss_ << str; 102 } 103 104 ~Message() { delete ss_; } 105 #if GTEST_OS_SYMBIAN 106 // Streams a value (either a pointer or not) to this object. 107 template <typename T> 108 inline Message& operator <<(const T& value) { 109 StreamHelper(typename internal::is_pointer<T>::type(), value); 110 return *this; 111 } 112 #else 113 // Streams a non-pointer value to this object. 114 template <typename T> 115 inline Message& operator <<(const T& val) { 116 ::GTestStreamToHelper(ss_, val); 117 return *this; 118 } 119 120 // Streams a pointer value to this object. 121 // 122 // This function is an overload of the previous one. When you 123 // stream a pointer to a Message, this definition will be used as it 124 // is more specialized. (The C++ Standard, section 125 // [temp.func.order].) If you stream a non-pointer, then the 126 // previous definition will be used. 127 // 128 // The reason for this overload is that streaming a NULL pointer to 129 // ostream is undefined behavior. Depending on the compiler, you 130 // may get "0", "(nil)", "(null)", or an access violation. To 131 // ensure consistent result across compilers, we always treat NULL 132 // as "(null)". 133 template <typename T> 134 inline Message& operator <<(T* const& pointer) { // NOLINT 135 if (pointer == NULL) { 136 *ss_ << "(null)"; 137 } else { 138 ::GTestStreamToHelper(ss_, pointer); 139 } 140 return *this; 141 } 142 #endif // GTEST_OS_SYMBIAN 143 144 // Since the basic IO manipulators are overloaded for both narrow 145 // and wide streams, we have to provide this specialized definition 146 // of operator <<, even though its body is the same as the 147 // templatized version above. Without this definition, streaming 148 // endl or other basic IO manipulators to Message will confuse the 149 // compiler. 150 Message& operator <<(BasicNarrowIoManip val) { 151 *ss_ << val; 152 return *this; 153 } 154 155 // Instead of 1/0, we want to see true/false for bool values. 156 Message& operator <<(bool b) { 157 return *this << (b ? "true" : "false"); 158 } 159 160 // These two overloads allow streaming a wide C string to a Message 161 // using the UTF-8 encoding. 162 Message& operator <<(const wchar_t* wide_c_str) { 163 return *this << internal::String::ShowWideCString(wide_c_str); 164 } 165 Message& operator <<(wchar_t* wide_c_str) { 166 return *this << internal::String::ShowWideCString(wide_c_str); 167 } 168 169 #if GTEST_HAS_STD_WSTRING 170 // Converts the given wide string to a narrow string using the UTF-8 171 // encoding, and streams the result to this Message object. 172 Message& operator <<(const ::std::wstring& wstr); 173 #endif // GTEST_HAS_STD_WSTRING 174 175 #if GTEST_HAS_GLOBAL_WSTRING 176 // Converts the given wide string to a narrow string using the UTF-8 177 // encoding, and streams the result to this Message object. 178 Message& operator <<(const ::wstring& wstr); 179 #endif // GTEST_HAS_GLOBAL_WSTRING 180 181 // Gets the text streamed to this object so far as a String. 182 // Each '\0' character in the buffer is replaced with "\\0". 183 // 184 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 185 internal::String GetString() const { 186 return internal::StrStreamToString(ss_); 187 } 188 189 private: 190 #if GTEST_OS_SYMBIAN 191 // These are needed as the Nokia Symbian Compiler cannot decide between 192 // const T& and const T* in a function template. The Nokia compiler _can_ 193 // decide between class template specializations for T and T*, so a 194 // tr1::type_traits-like is_pointer works, and we can overload on that. 195 template <typename T> 196 inline void StreamHelper(internal::true_type dummy, T* pointer) { 197 if (pointer == NULL) { 198 *ss_ << "(null)"; 199 } else { 200 ::GTestStreamToHelper(ss_, pointer); 201 } 202 } 203 template <typename T> 204 inline void StreamHelper(internal::false_type dummy, const T& value) { 205 ::GTestStreamToHelper(ss_, value); 206 } 207 #endif // GTEST_OS_SYMBIAN 208 209 // We'll hold the text streamed to this object here. 210 internal::StrStream* const ss_; 211 212 // We declare (but don't implement) this to prevent the compiler 213 // from implementing the assignment operator. 214 void operator=(const Message&); 215 }; 216 217 // Streams a Message to an ostream. 218 inline std::ostream& operator <<(std::ostream& os, const Message& sb) { 219 return os << sb.GetString(); 220 } 221 222 } // namespace testing 223 224 #endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 225