0
|
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@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 <limits> |
|
50 |
|
51 #include "gtest/internal/gtest-port.h" |
|
52 |
|
53 // Ensures that there is at least one operator<< in the global namespace. |
|
54 // See Message& operator<<(...) below for why. |
|
55 void operator<<(const testing::internal::Secret&, int); |
|
56 |
|
57 namespace testing { |
|
58 |
|
59 // The Message class works like an ostream repeater. |
|
60 // |
|
61 // Typical usage: |
|
62 // |
|
63 // 1. You stream a bunch of values to a Message object. |
|
64 // It will remember the text in a stringstream. |
|
65 // 2. Then you stream the Message object to an ostream. |
|
66 // This causes the text in the Message to be streamed |
|
67 // to the ostream. |
|
68 // |
|
69 // For example; |
|
70 // |
|
71 // testing::Message foo; |
|
72 // foo << 1 << " != " << 2; |
|
73 // std::cout << foo; |
|
74 // |
|
75 // will print "1 != 2". |
|
76 // |
|
77 // Message is not intended to be inherited from. In particular, its |
|
78 // destructor is not virtual. |
|
79 // |
|
80 // Note that stringstream behaves differently in gcc and in MSVC. You |
|
81 // can stream a NULL char pointer to it in the former, but not in the |
|
82 // latter (it causes an access violation if you do). The Message |
|
83 // class hides this difference by treating a NULL char pointer as |
|
84 // "(null)". |
|
85 class GTEST_API_ Message { |
|
86 private: |
|
87 // The type of basic IO manipulators (endl, ends, and flush) for |
|
88 // narrow streams. |
|
89 typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); |
|
90 |
|
91 public: |
|
92 // Constructs an empty Message. |
|
93 Message(); |
|
94 |
|
95 // Copy constructor. |
|
96 Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT |
|
97 *ss_ << msg.GetString(); |
|
98 } |
|
99 |
|
100 // Constructs a Message from a C-string. |
|
101 explicit Message(const char* str) : ss_(new ::std::stringstream) { |
|
102 *ss_ << str; |
|
103 } |
|
104 |
|
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 // Some libraries overload << for STL containers. These |
|
117 // overloads are defined in the global namespace instead of ::std. |
|
118 // |
|
119 // C++'s symbol lookup rule (i.e. Koenig lookup) says that these |
|
120 // overloads are visible in either the std namespace or the global |
|
121 // namespace, but not other namespaces, including the testing |
|
122 // namespace which Google Test's Message class is in. |
|
123 // |
|
124 // To allow STL containers (and other types that has a << operator |
|
125 // defined in the global namespace) to be used in Google Test |
|
126 // assertions, testing::Message must access the custom << operator |
|
127 // from the global namespace. With this using declaration, |
|
128 // overloads of << defined in the global namespace and those |
|
129 // visible via Koenig lookup are both exposed in this function. |
|
130 using ::operator <<; |
|
131 *ss_ << val; |
|
132 return *this; |
|
133 } |
|
134 |
|
135 // Streams a pointer value to this object. |
|
136 // |
|
137 // This function is an overload of the previous one. When you |
|
138 // stream a pointer to a Message, this definition will be used as it |
|
139 // is more specialized. (The C++ Standard, section |
|
140 // [temp.func.order].) If you stream a non-pointer, then the |
|
141 // previous definition will be used. |
|
142 // |
|
143 // The reason for this overload is that streaming a NULL pointer to |
|
144 // ostream is undefined behavior. Depending on the compiler, you |
|
145 // may get "0", "(nil)", "(null)", or an access violation. To |
|
146 // ensure consistent result across compilers, we always treat NULL |
|
147 // as "(null)". |
|
148 template <typename T> |
|
149 inline Message& operator <<(T* const& pointer) { // NOLINT |
|
150 if (pointer == NULL) { |
|
151 *ss_ << "(null)"; |
|
152 } else { |
|
153 *ss_ << pointer; |
|
154 } |
|
155 return *this; |
|
156 } |
|
157 #endif // GTEST_OS_SYMBIAN |
|
158 |
|
159 // Since the basic IO manipulators are overloaded for both narrow |
|
160 // and wide streams, we have to provide this specialized definition |
|
161 // of operator <<, even though its body is the same as the |
|
162 // templatized version above. Without this definition, streaming |
|
163 // endl or other basic IO manipulators to Message will confuse the |
|
164 // compiler. |
|
165 Message& operator <<(BasicNarrowIoManip val) { |
|
166 *ss_ << val; |
|
167 return *this; |
|
168 } |
|
169 |
|
170 // Instead of 1/0, we want to see true/false for bool values. |
|
171 Message& operator <<(bool b) { |
|
172 return *this << (b ? "true" : "false"); |
|
173 } |
|
174 |
|
175 // These two overloads allow streaming a wide C string to a Message |
|
176 // using the UTF-8 encoding. |
|
177 Message& operator <<(const wchar_t* wide_c_str); |
|
178 Message& operator <<(wchar_t* wide_c_str); |
|
179 |
|
180 #if GTEST_HAS_STD_WSTRING |
|
181 // Converts the given wide string to a narrow string using the UTF-8 |
|
182 // encoding, and streams the result to this Message object. |
|
183 Message& operator <<(const ::std::wstring& wstr); |
|
184 #endif // GTEST_HAS_STD_WSTRING |
|
185 |
|
186 #if GTEST_HAS_GLOBAL_WSTRING |
|
187 // Converts the given wide string to a narrow string using the UTF-8 |
|
188 // encoding, and streams the result to this Message object. |
|
189 Message& operator <<(const ::wstring& wstr); |
|
190 #endif // GTEST_HAS_GLOBAL_WSTRING |
|
191 |
|
192 // Gets the text streamed to this object so far as an std::string. |
|
193 // Each '\0' character in the buffer is replaced with "\\0". |
|
194 // |
|
195 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. |
|
196 std::string GetString() const; |
|
197 |
|
198 private: |
|
199 |
|
200 #if GTEST_OS_SYMBIAN |
|
201 // These are needed as the Nokia Symbian Compiler cannot decide between |
|
202 // const T& and const T* in a function template. The Nokia compiler _can_ |
|
203 // decide between class template specializations for T and T*, so a |
|
204 // tr1::type_traits-like is_pointer works, and we can overload on that. |
|
205 template <typename T> |
|
206 inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) { |
|
207 if (pointer == NULL) { |
|
208 *ss_ << "(null)"; |
|
209 } else { |
|
210 *ss_ << pointer; |
|
211 } |
|
212 } |
|
213 template <typename T> |
|
214 inline void StreamHelper(internal::false_type /*is_pointer*/, |
|
215 const T& value) { |
|
216 // See the comments in Message& operator <<(const T&) above for why |
|
217 // we need this using statement. |
|
218 using ::operator <<; |
|
219 *ss_ << value; |
|
220 } |
|
221 #endif // GTEST_OS_SYMBIAN |
|
222 |
|
223 // We'll hold the text streamed to this object here. |
|
224 const internal::scoped_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 #endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ |