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