Mercurial > libbase64
comparison gtest/include/gtest/gtest-message.h @ 0:a7fa8fee3d83
Initial import
author | David Demelier <markand@malikania.fr> |
---|---|
date | Tue, 30 Aug 2016 13:28:05 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a7fa8fee3d83 |
---|---|
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_ |