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