Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
stenzek
GitHub Repository: stenzek/duckstation
Path: blob/master/dep/googletest/include/gtest/gtest-message.h
4806 views
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/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 <
125
typename T
126
#ifdef GTEST_HAS_ABSL
127
,
128
typename std::enable_if<!absl::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<absl::HasAbslStringify<T>::value, // NOLINT
157
int>::type = 0>
158
inline Message& operator<<(const T& val) {
159
// ::operator<< is needed here for a similar reason as with the non-Abseil
160
// version above
161
using ::operator<<;
162
*ss_ << absl::StrCat(val);
163
return *this;
164
}
165
#endif // GTEST_HAS_ABSL
166
167
// Streams a pointer value to this object.
168
//
169
// This function is an overload of the previous one. When you
170
// stream a pointer to a Message, this definition will be used as it
171
// is more specialized. (The C++ Standard, section
172
// [temp.func.order].) If you stream a non-pointer, then the
173
// previous definition will be used.
174
//
175
// The reason for this overload is that streaming a NULL pointer to
176
// ostream is undefined behavior. Depending on the compiler, you
177
// may get "0", "(nil)", "(null)", or an access violation. To
178
// ensure consistent result across compilers, we always treat NULL
179
// as "(null)".
180
template <typename T>
181
inline Message& operator<<(T* const& pointer) { // NOLINT
182
if (pointer == nullptr) {
183
*ss_ << "(null)";
184
} else {
185
*ss_ << pointer;
186
}
187
return *this;
188
}
189
190
// Since the basic IO manipulators are overloaded for both narrow
191
// and wide streams, we have to provide this specialized definition
192
// of operator <<, even though its body is the same as the
193
// templatized version above. Without this definition, streaming
194
// endl or other basic IO manipulators to Message will confuse the
195
// compiler.
196
Message& operator<<(BasicNarrowIoManip val) {
197
*ss_ << val;
198
return *this;
199
}
200
201
// Instead of 1/0, we want to see true/false for bool values.
202
Message& operator<<(bool b) { return *this << (b ? "true" : "false"); }
203
204
// These two overloads allow streaming a wide C string to a Message
205
// using the UTF-8 encoding.
206
Message& operator<<(const wchar_t* wide_c_str);
207
Message& operator<<(wchar_t* wide_c_str);
208
209
#if GTEST_HAS_STD_WSTRING
210
// Converts the given wide string to a narrow string using the UTF-8
211
// encoding, and streams the result to this Message object.
212
Message& operator<<(const ::std::wstring& wstr);
213
#endif // GTEST_HAS_STD_WSTRING
214
215
// Gets the text streamed to this object so far as an std::string.
216
// Each '\0' character in the buffer is replaced with "\\0".
217
//
218
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
219
std::string GetString() const;
220
221
private:
222
// We'll hold the text streamed to this object here.
223
const std::unique_ptr< ::std::stringstream> ss_;
224
225
// We declare (but don't implement) this to prevent the compiler
226
// from implementing the assignment operator.
227
void operator=(const Message&);
228
};
229
230
// Streams a Message to an ostream.
231
inline std::ostream& operator<<(std::ostream& os, const Message& sb) {
232
return os << sb.GetString();
233
}
234
235
namespace internal {
236
237
// Converts a streamable value to an std::string. A NULL pointer is
238
// converted to "(null)". When the input value is a ::string,
239
// ::std::string, ::wstring, or ::std::wstring object, each NUL
240
// character in it is replaced with "\\0".
241
template <typename T>
242
std::string StreamableToString(const T& streamable) {
243
return (Message() << streamable).GetString();
244
}
245
246
} // namespace internal
247
} // namespace testing
248
249
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
250
251
#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
252
253