gtest-port.h 36.3 KB
Newer Older
shiqian's avatar
shiqian committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: wan@google.com (Zhanyong Wan)
//
// Low-level types and utilities for porting Google Test to various
// platforms.  They are subject to change without notice.  DO NOT USE
// THEM IN USER CODE.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

// The user can define the following macros in the build script to
shiqian's avatar
shiqian committed
40
41
// control Google Test's behavior.  If the user doesn't define a macro
// in this list, Google Test will define it.
shiqian's avatar
shiqian committed
42
//
43
44
//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
//                              is/isn't available.
shiqian's avatar
shiqian committed
45
46
47
48
49
50
//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
//                              is/isn't available (some systems define
//                              ::string, which is different to std::string).
//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
//                              is/isn't available (some systems define
//                              ::wstring, which is different to std::wstring).
shiqian's avatar
shiqian committed
51
52
//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
//                              is/isn't available.
53
54
55
56
57
//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
//                              enabled.
//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
//                              std::wstring does/doesn't work (Google Test can
//                              be used where std::wstring is unavailable).
58
//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
59
//                              is/isn't available.
60
61
62
//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
//                              compiler supports Microsoft's "Structured
//                              Exception Handling".
63
64
65
66
//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
//                              Test's own tr1 tuple implementation should be
//                              used.  Unused when the user sets
//                              GTEST_HAS_TR1_TUPLE to 0.
shiqian's avatar
shiqian committed
67
68
69

// This header defines the following utilities:
//
zhanyong.wan's avatar
zhanyong.wan committed
70
71
72
73
74
75
76
// Macros indicating the current platform (defined to 1 if compiled on
// the given platform; otherwise undefined):
//   GTEST_OS_CYGWIN   - Cygwin
//   GTEST_OS_LINUX    - Linux
//   GTEST_OS_MAC      - Mac OS X
//   GTEST_OS_SOLARIS  - Sun Solaris
//   GTEST_OS_SYMBIAN  - Symbian
77
78
79
80
//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
//     GTEST_OS_WINDOWS_MINGW    - MinGW
//     GTEST_OS_WINODWS_MOBILE   - Windows Mobile
zhanyong.wan's avatar
zhanyong.wan committed
81
//   GTEST_OS_ZOS      - z/OS
82
//
83
84
85
86
87
88
89
// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
// most stable support.  Since core members of the Google Test project
// don't have access to other platforms, support for them may be less
// stable.  If you notice any problems on your platform, please notify
// googletestframework@googlegroups.com (patches for fixing them are
// even more welcome!).
//
zhanyong.wan's avatar
zhanyong.wan committed
90
// Note that it is possible that none of the GTEST_OS_* macros are defined.
shiqian's avatar
shiqian committed
91
//
zhanyong.wan's avatar
zhanyong.wan committed
92
93
94
95
96
97
98
99
100
101
// Macros indicating available Google Test features (defined to 1 if
// the corresponding feature is supported; otherwise undefined):
//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
//                            tests)
//   GTEST_HAS_DEATH_TEST   - death tests
//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
//   GTEST_HAS_TYPED_TEST   - typed tests
//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used.
//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
102
//                            the above two are mutually exclusive.
shiqian's avatar
shiqian committed
103
104
//
// Macros for basic C++ coding:
shiqian's avatar
shiqian committed
105
//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
106
107
//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
//                              variable don't have to be used.
108
//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
shiqian's avatar
shiqian committed
109
110
//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
shiqian's avatar
shiqian committed
111
112
113
114
//
// Synchronization:
//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
//                  - synchronization primitives.
shiqian's avatar
shiqian committed
115
116
117
//   GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
//                         synchronization primitives have real implementations
//                         and Google Test is thread-safe; or 0 otherwise.
shiqian's avatar
shiqian committed
118
119
//
// Template meta programming:
120
//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
shiqian's avatar
shiqian committed
121
122
123
124
125
126
127
128
129
130
//
// Smart pointers:
//   scoped_ptr     - as in TR2.
//
// Regular expressions:
//   RE             - a simple regular expression class using the POSIX
//                    Extended Regular Expression syntax.  Not available on
//                    Windows.
//
// Logging:
shiqian's avatar
shiqian committed
131
//   GTEST_LOG_()   - logs messages at the specified severity level.
shiqian's avatar
shiqian committed
132
133
134
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.
//
135
136
137
138
// Stdout and stderr capturing:
//   CaptureStdout()     - starts capturing stdout.
//   GetCapturedStdout() - stops capturing stdout and returns the captured
//                         string.
shiqian's avatar
shiqian committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
//   CaptureStderr()     - starts capturing stderr.
//   GetCapturedStderr() - stops capturing stderr and returns the captured
//                         string.
//
// Integer types:
//   TypeWithSize   - maps an integer to a int type.
//   Int32, UInt32, Int64, UInt64, TimeInMillis
//                  - integers of known sizes.
//   BiggestInt     - the biggest signed integer type.
//
// Command-line utilities:
//   GTEST_FLAG()       - references a flag.
//   GTEST_DECLARE_*()  - declares a flag.
//   GTEST_DEFINE_*()   - defines a flag.
//   GetArgvs()         - returns the command line as a vector of strings.
//
// Environment variable utilities:
//   GetEnv()             - gets the value of an environment variable.
//   BoolFromGTestEnv()   - parses a bool environment variable.
//   Int32FromGTestEnv()  - parses an Int32 environment variable.
//   StringFromGTestEnv() - parses a string environment variable.

161
#include <stddef.h>  // For ptrdiff_t
shiqian's avatar
shiqian committed
162
163
#include <stdlib.h>
#include <stdio.h>
164
#include <string.h>
165
#ifndef _WIN32_WCE
166
#include <sys/stat.h>
167
#endif  // !_WIN32_WCE
168
169

#include <iostream>  // NOLINT
170
171
#include <sstream>  // NOLINT
#include <string>  // NOLINT
shiqian's avatar
shiqian committed
172

173
#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
zhanyong.wan's avatar
zhanyong.wan committed
174
#define GTEST_FLAG_PREFIX_ "gtest_"
175
#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
zhanyong.wan's avatar
zhanyong.wan committed
176
#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
177
178
#define GTEST_NAME_ "Google Test"
#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
shiqian's avatar
shiqian committed
179

shiqian's avatar
shiqian committed
180
181
182
183
184
185
186
// Determines the version of gcc that is used to compile this.
#ifdef __GNUC__
// 40302 means version 4.3.2.
#define GTEST_GCC_VER_ \
    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
#endif  // __GNUC__

shiqian's avatar
shiqian committed
187
// Determines the platform on which Google Test is compiled.
188
#ifdef __CYGWIN__
zhanyong.wan's avatar
zhanyong.wan committed
189
#define GTEST_OS_CYGWIN 1
190
#elif defined __SYMBIAN32__
zhanyong.wan's avatar
zhanyong.wan committed
191
#define GTEST_OS_SYMBIAN 1
192
#elif defined _WIN32
zhanyong.wan's avatar
zhanyong.wan committed
193
#define GTEST_OS_WINDOWS 1
194
195
196
197
198
199
200
#ifdef _WIN32_WCE
#define GTEST_OS_WINDOWS_MOBILE 1
#elif defined(__MINGW__) || defined(__MINGW32__)
#define GTEST_OS_WINDOWS_MINGW 1
#else
#define GTEST_OS_WINDOWS_DESKTOP 1
#endif  // _WIN32_WCE
shiqian's avatar
shiqian committed
201
#elif defined __APPLE__
zhanyong.wan's avatar
zhanyong.wan committed
202
#define GTEST_OS_MAC 1
shiqian's avatar
shiqian committed
203
#elif defined __linux__
zhanyong.wan's avatar
zhanyong.wan committed
204
#define GTEST_OS_LINUX 1
205
#elif defined __MVS__
zhanyong.wan's avatar
zhanyong.wan committed
206
#define GTEST_OS_ZOS 1
207
#elif defined(__sun) && defined(__SVR4)
zhanyong.wan's avatar
zhanyong.wan committed
208
#define GTEST_OS_SOLARIS 1
209
#endif  // __CYGWIN__
shiqian's avatar
shiqian committed
210

211
212
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
    GTEST_OS_SOLARIS
213
214
215
216
217
218

// On some platforms, <regex.h> needs someone to define size_t, and
// won't compile otherwise.  We can #include it here as we already
// included <stdlib.h>, which is guaranteed to define size_t through
// <stddef.h>.
#include <regex.h>  // NOLINT
219
220
221
222
#include <strings.h>  // NOLINT
#include <sys/types.h>  // NOLINT
#include <unistd.h>  // NOLINT

223
224
#define GTEST_USES_POSIX_RE 1

225
226
#elif GTEST_OS_WINDOWS

227
#if !GTEST_OS_WINDOWS_MOBILE
228
229
#include <direct.h>  // NOLINT
#include <io.h>  // NOLINT
230
#endif
231
232
233
234
235

// <regex.h> is not available on Windows.  Use our own simple regex
// implementation instead.
#define GTEST_USES_SIMPLE_RE 1

236
237
#else

238
239
// <regex.h> may not be available on this platform.  Use our own
// simple regex implementation instead.
240
241
#define GTEST_USES_SIMPLE_RE 1

242
243
#endif  // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
        // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
244

245
246
// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0
// otherwise.
shiqian's avatar
shiqian committed
247

248
249
250
#if defined(_MSC_VER) || defined(__BORLANDC__)
// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
// macro to enable exceptions, so we'll do the same.
shiqian's avatar
shiqian committed
251
// Assumes that exceptions are enabled by default.
252
#ifndef _HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
253
254
255
#define _HAS_EXCEPTIONS 1
#endif  // _HAS_EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
256
#else  // The compiler is not MSVC or C++Builder.
257
258
259
// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.  For
// other compilers, we assume exceptions are disabled to be
// conservative.
260
261
262
263
264
#if defined(__GNUC__) && __EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS 1
#else
#define GTEST_HAS_EXCEPTIONS 0
#endif  // defined(__GNUC__) && __EXCEPTIONS
265
#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
shiqian's avatar
shiqian committed
266

267
268
269
#if !defined(GTEST_HAS_STD_STRING)
// Even though we don't use this macro any longer, we keep it in case
// some clients still depend on it.
270
#define GTEST_HAS_STD_STRING 1
271
272
273
274
#elif !GTEST_HAS_STD_STRING
// The user told us that ::std::string isn't available.
#error "Google Test cannot be used where ::std::string isn't available."
#endif  // !defined(GTEST_HAS_STD_STRING)
shiqian's avatar
shiqian committed
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

#ifndef GTEST_HAS_GLOBAL_STRING
// The user didn't tell us whether ::string is available, so we need
// to figure it out.

#define GTEST_HAS_GLOBAL_STRING 0

#endif  // GTEST_HAS_GLOBAL_STRING

#ifndef GTEST_HAS_STD_WSTRING
// The user didn't tell us whether ::std::wstring is available, so we need
// to figure it out.
// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
//   is available.

290
291
// Cygwin 1.5 and below doesn't support ::std::wstring.
// Cygwin 1.7 might add wstring support; this should be updated when clear.
292
// Solaris' libc++ doesn't support it either.
293
#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
shiqian's avatar
shiqian committed
294
295
296
297
298
299

#endif  // GTEST_HAS_STD_WSTRING

#ifndef GTEST_HAS_GLOBAL_WSTRING
// The user didn't tell us whether ::wstring is available, so we need
// to figure it out.
300
301
#define GTEST_HAS_GLOBAL_WSTRING \
    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
shiqian's avatar
shiqian committed
302
303
#endif  // GTEST_HAS_GLOBAL_WSTRING

shiqian's avatar
shiqian committed
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
// Determines whether RTTI is available.
#ifndef GTEST_HAS_RTTI
// The user didn't tell us whether RTTI is enabled, so we need to
// figure it out.

#ifdef _MSC_VER

#ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
#define GTEST_HAS_RTTI 1
#else
#define GTEST_HAS_RTTI 0
#endif  // _CPPRTTI

#elif defined(__GNUC__)

// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
#if GTEST_GCC_VER_ >= 40302
#ifdef __GXX_RTTI
#define GTEST_HAS_RTTI 1
#else
#define GTEST_HAS_RTTI 0
#endif  // __GXX_RTTI
#else
// For gcc versions smaller than 4.3.2, we assume RTTI is enabled.
#define GTEST_HAS_RTTI 1
#endif  // GTEST_GCC_VER >= 40302

#else

// Unknown compiler - assume RTTI is enabled.
#define GTEST_HAS_RTTI 1

#endif  // _MSC_VER

#endif  // GTEST_HAS_RTTI

shiqian's avatar
shiqian committed
340
341
342
// Determines whether <pthread.h> is available.
#ifndef GTEST_HAS_PTHREAD
// The user didn't tell us, so we need to figure it out.
zhanyong.wan's avatar
zhanyong.wan committed
343
#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC)
shiqian's avatar
shiqian committed
344
345
#endif  // GTEST_HAS_PTHREAD

346
347
348
// Determines whether Google Test can use tr1/tuple.  You can define
// this macro to 0 to prevent Google Test from using tuple (any
// feature depending on tuple with be disabled in this mode).
349
#ifndef GTEST_HAS_TR1_TUPLE
350
351
352
353
354
355
356
// The user didn't tell us not to do it, so we assume it's OK.
#define GTEST_HAS_TR1_TUPLE 1
#endif  // GTEST_HAS_TR1_TUPLE

// Determines whether Google Test's own tr1 tuple implementation
// should be used.
#ifndef GTEST_USE_OWN_TR1_TUPLE
357
358
// The user didn't tell us, so we need to figure it out.

359
// We use our own TR1 tuple if we aren't sure the user has an
360
361
// implementation of it already.  At this time, GCC 4.0.0+ and MSVC
// 2010 are the only mainstream compilers that come with a TR1 tuple
362
363
// implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
// defining __GNUC__ and friends, but cannot compile GCC's tuple
364
365
// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
// Feature Pack download, which we cannot assume the user has.
366
367
#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
    || _MSC_VER >= 1600
368
#define GTEST_USE_OWN_TR1_TUPLE 0
369
#else
370
#define GTEST_USE_OWN_TR1_TUPLE 1
371
#endif
372
373

#endif  // GTEST_USE_OWN_TR1_TUPLE
374

375
376
377
378
// To avoid conditional compilation everywhere, we make it
// gtest-port.h's responsibility to #include the header implementing
// tr1/tuple.
#if GTEST_HAS_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
379

380
381
382
#if GTEST_USE_OWN_TR1_TUPLE
#include <gtest/internal/gtest-tuple.h>
#elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398

// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
// use STLport's tuple implementation, which unfortunately doesn't
// work as the copy of STLport distributed with Symbian is incomplete.
// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
// use its own tuple implementation.
#ifdef BOOST_HAS_TR1_TUPLE
#undef BOOST_HAS_TR1_TUPLE
#endif  // BOOST_HAS_TR1_TUPLE

// This prevents <boost/tr1/detail/config.hpp>, which defines
// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
#include <tuple>

#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
399
400
// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
// not conform to the TR1 spec, which requires the header to be <tuple>.
401
402
403
404
405
406
407
408
409
410
411
412

#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
// which is #included by <tr1/tuple>, to not compile when RTTI is
// disabled.  _TR1_FUNCTIONAL is the header guard for
// <tr1/functional>.  Hence the following #define is a hack to prevent
// <tr1/functional> from being included.
#define _TR1_FUNCTIONAL 1
#include <tr1/tuple>
#undef _TR1_FUNCTIONAL  // Allows the user to #include
                        // <tr1/functional> if he chooses to.
#else
413
#include <tr1/tuple>  // NOLINT
414
415
#endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

416
#else
417
// If the compiler is not GCC 4.0+, we assume the user is using a
418
// spec-conforming TR1 implementation.
419
#include <tuple>  // NOLINT
420
#endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
421

422
423
#endif  // GTEST_HAS_TR1_TUPLE

424
425
426
427
428
429
430
// Determines whether clone(2) is supported.
// Usually it will only be available on Linux, excluding
// Linux on the Itanium architecture.
// Also see http://linux.die.net/man/2/clone.
#ifndef GTEST_HAS_CLONE
// The user didn't tell us, so we need to figure it out.

zhanyong.wan's avatar
zhanyong.wan committed
431
#if GTEST_OS_LINUX && !defined(__ia64__)
432
433
434
#define GTEST_HAS_CLONE 1
#else
#define GTEST_HAS_CLONE 0
zhanyong.wan's avatar
zhanyong.wan committed
435
#endif  // GTEST_OS_LINUX && !defined(__ia64__)
436
437
438

#endif  // GTEST_HAS_CLONE

shiqian's avatar
shiqian committed
439
// Determines whether to support death tests.
440
441
442
443
// Google Test does not support death tests for VC 7.1 and earlier as
// abort() in a VC 7.1 application compiled as GUI in debug config
// pops up a dialog window that cannot be suppressed programmatically.
#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || \
444
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
zhanyong.wan's avatar
zhanyong.wan committed
445
#define GTEST_HAS_DEATH_TEST 1
446
#include <vector>  // NOLINT
447
#endif
shiqian's avatar
shiqian committed
448

449
450
451
452
453
// Determines whether to support value-parameterized tests.

#if defined(__GNUC__) || (_MSC_VER >= 1400)
// TODO(vladl@google.com): get the implementation rid of vector and list
// to compile on MSVC 7.1.
zhanyong.wan's avatar
zhanyong.wan committed
454
#define GTEST_HAS_PARAM_TEST 1
455
456
#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)

457
458
459
460
461
// Determines whether to support type-driven tests.

// Typed tests need <typeinfo> and variadic macros, which gcc and VC
// 8.0+ support.
#if defined(__GNUC__) || (_MSC_VER >= 1400)
462
463
#define GTEST_HAS_TYPED_TEST 1
#define GTEST_HAS_TYPED_TEST_P 1
464
465
#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)

466
467
// Determines whether to support Combine(). This only makes sense when
// value-parameterized tests are enabled.
zhanyong.wan's avatar
zhanyong.wan committed
468
469
470
#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
#define GTEST_HAS_COMBINE 1
#endif  // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
471

472
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
zhanyong.wan's avatar
zhanyong.wan committed
473
474
#define GTEST_WIDE_STRING_USES_UTF16_ \
    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
475

shiqian's avatar
shiqian committed
476
477
478
479
480
481
482
483
484
485
486
// Defines some utility macros.

// The GNU compiler emits a warning if nested "if" statements are followed by
// an "else" statement and braces are not used to explicitly disambiguate the
// "else" binding.  This leads to problems with code like:
//
//   if (gate)
//     ASSERT_*(condition) << "Some message";
//
// The "switch (0) case 0:" idiom is used to suppress this.
#ifdef __INTEL_COMPILER
shiqian's avatar
shiqian committed
487
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
shiqian's avatar
shiqian committed
488
#else
shiqian's avatar
shiqian committed
489
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0:  // NOLINT
shiqian's avatar
shiqian committed
490
491
#endif

492
// Use this annotation at the end of a struct/class definition to
shiqian's avatar
shiqian committed
493
494
495
496
497
498
// prevent the compiler from optimizing away instances that are never
// used.  This is useful when all interesting logic happens inside the
// c'tor and / or d'tor.  Example:
//
//   struct Foo {
//     Foo() { ... }
shiqian's avatar
shiqian committed
499
//   } GTEST_ATTRIBUTE_UNUSED_;
500
501
502
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
503
#if defined(__GNUC__) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
504
#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
505
#else
shiqian's avatar
shiqian committed
506
#define GTEST_ATTRIBUTE_UNUSED_
507
#endif
shiqian's avatar
shiqian committed
508

509
510
511
512
513
514
// A macro to disallow operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_ASSIGN_(type)\
  void operator=(type const &)

// A macro to disallow copy constructor and operator=
shiqian's avatar
shiqian committed
515
// This should be used in the private: declarations for a class.
shiqian's avatar
shiqian committed
516
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
517
518
  type(type const &);\
  GTEST_DISALLOW_ASSIGN_(type)
shiqian's avatar
shiqian committed
519
520
521
522
523

// Tell the compiler to warn about unused return values for functions declared
// with this macro.  The macro should be used on function declarations
// following the argument list:
//
shiqian's avatar
shiqian committed
524
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
525
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
526
#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
shiqian's avatar
shiqian committed
527
#else
shiqian's avatar
shiqian committed
528
#define GTEST_MUST_USE_RESULT_
shiqian's avatar
shiqian committed
529
#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
shiqian's avatar
shiqian committed
530

531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
// Determine whether the compiler supports Microsoft's Structured Exception
// Handling.  This is supported by several Windows compilers but generally
// does not exist on any other system.
#ifndef GTEST_HAS_SEH
// The user didn't tell us, so we need to figure it out.

#if defined(_MSC_VER) || defined(__BORLANDC__)
// These two compilers are known to support SEH.
#define GTEST_HAS_SEH 1
#else
// Assume no SEH.
#define GTEST_HAS_SEH 0
#endif

#endif  // GTEST_HAS_SEH

shiqian's avatar
shiqian committed
547
548
549
550
551
552
553
554
555
556
namespace testing {

class Message;

namespace internal {

class String;

typedef ::std::stringstream StrStream;

557
558
559
560
// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
bool IsTrue(bool condition);

shiqian's avatar
shiqian committed
561
562
563
564
565
566
567
// Defines scoped_ptr.

// This implementation of scoped_ptr is PARTIAL - it only contains
// enough stuff to satisfy Google Test's need.
template <typename T>
class scoped_ptr {
 public:
568
569
  typedef T element_type;

shiqian's avatar
shiqian committed
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
  ~scoped_ptr() { reset(); }

  T& operator*() const { return *ptr_; }
  T* operator->() const { return ptr_; }
  T* get() const { return ptr_; }

  T* release() {
    T* const ptr = ptr_;
    ptr_ = NULL;
    return ptr;
  }

  void reset(T* p = NULL) {
    if (p != ptr_) {
585
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
shiqian's avatar
shiqian committed
586
587
588
589
590
591
592
593
        delete ptr_;
      }
      ptr_ = p;
    }
  }
 private:
  T* ptr_;

shiqian's avatar
shiqian committed
594
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
595
596
};

597
// Defines RE.
shiqian's avatar
shiqian committed
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615

// A simple C++ wrapper for <regex.h>.  It uses the POSIX Enxtended
// Regular Expression syntax.
class RE {
 public:
  // Constructs an RE from a string.
  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT

#if GTEST_HAS_GLOBAL_STRING
  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
#endif  // GTEST_HAS_GLOBAL_STRING

  RE(const char* regex) { Init(regex); }  // NOLINT
  ~RE();

  // Returns the string representation of the regex.
  const char* pattern() const { return pattern_; }

616
617
618
619
620
621
622
623
624
625
  // FullMatch(str, re) returns true iff regular expression re matches
  // the entire str.
  // PartialMatch(str, re) returns true iff regular expression re
  // matches a substring of str (including str itself).
  //
  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
  // when str contains NUL characters.
  static bool FullMatch(const ::std::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
626
627
628
629
630
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

#if GTEST_HAS_GLOBAL_STRING
631
632
633
  static bool FullMatch(const ::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
634
635
636
637
638
  static bool PartialMatch(const ::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }
#endif  // GTEST_HAS_GLOBAL_STRING

639
  static bool FullMatch(const char* str, const RE& re);
shiqian's avatar
shiqian committed
640
641
642
643
644
645
646
647
648
649
  static bool PartialMatch(const char* str, const RE& re);

 private:
  void Init(const char* regex);

  // We use a const char* instead of a string, as Google Test may be used
  // where string is not available.  We also do not use Google Test's own
  // String type here, in order to simplify dependencies between the
  // files.
  const char* pattern_;
650
651
  bool is_valid_;
#if GTEST_USES_POSIX_RE
652
653
  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().
654
655
656
#else  // GTEST_USES_SIMPLE_RE
  const char* full_pattern_;  // For FullMatch();
#endif
shiqian's avatar
shiqian committed
657

658
659
  GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
};
shiqian's avatar
shiqian committed
660
661

// Defines logging utilities:
662
663
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
shiqian's avatar
shiqian committed
664
665
666
667
668
669
670
671
672
673
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

enum GTestLogSeverity {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
// Formats log entry severity, provides a stream object for streaming the
// log message, and terminates the message with a newline when going out of
// scope.
class GTestLog {
 public:
  GTestLog(GTestLogSeverity severity, const char* file, int line);

  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
  ~GTestLog();

  ::std::ostream& GetStream() { return ::std::cerr; }

 private:
  const GTestLogSeverity severity_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
};
shiqian's avatar
shiqian committed
691

692
693
694
#define GTEST_LOG_(severity) \
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()
shiqian's avatar
shiqian committed
695
696
697
698

inline void LogToStderr() {}
inline void FlushInfoLog() { fflush(NULL); }

699
700
#if !GTEST_OS_WINDOWS_MOBILE

shiqian's avatar
shiqian committed
701
// Defines the stderr capturer:
702
703
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
shiqian's avatar
shiqian committed
704
705
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
706
707
708
//
void CaptureStdout();
String GetCapturedStdout();
709
void CaptureStderr();
710
String GetCapturedStderr();
711

712
713
714
#endif  // !GTEST_OS_WINDOWS_MOBILE


zhanyong.wan's avatar
zhanyong.wan committed
715
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734

// A copy of all command line arguments.  Set by InitGoogleTest().
extern ::std::vector<String> g_argvs;

// GTEST_HAS_DEATH_TEST implies we have ::std::string.
const ::std::vector<String>& GetArgvs();

#endif  // GTEST_HAS_DEATH_TEST

// Defines synchronization primitives.

// A dummy implementation of synchronization primitives (mutex, lock,
// and thread-local variable).  Necessary for compiling Google Test where
// mutex is not supported - using Google Test in multiple threads is not
// supported on such platforms.

class Mutex {
 public:
  Mutex() {}
735
  explicit Mutex(int /*unused*/) {}
shiqian's avatar
shiqian committed
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
  void AssertHeld() const {}
  enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 };
};

// We cannot call it MutexLock directly as the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms.  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex*) {}  // NOLINT
};

typedef GTestMutexLock MutexLock;

template <typename T>
class ThreadLocal {
 public:
shiqian's avatar
shiqian committed
753
754
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
755
756
757
758
759
760
761
762
  T* pointer() { return &value_; }
  const T* pointer() const { return &value_; }
  const T& get() const { return value_; }
  void set(const T& value) { value_ = value; }
 private:
  T value_;
};

763
764
765
// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount();
shiqian's avatar
shiqian committed
766

shiqian's avatar
shiqian committed
767
768
769
770
// The above synchronization primitives have dummy implementations.
// Therefore Google Test is not thread-safe.
#define GTEST_IS_THREADSAFE 0

771
// Passing non-POD classes through ellipsis (...) crashes the ARM
772
773
774
775
776
777
778
779
// compiler and generates a warning in Sun Studio.  The Nokia Symbian
// and the IBM XL C/C++ compiler try to instantiate a copy constructor
// for objects passed through ellipsis (...), failing for uncopyable
// objects.  We define this to ensure that only POD is passed through
// ellipsis on these systems.
#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
#define GTEST_ELLIPSIS_NEEDS_POD_ 1
#endif
shiqian's avatar
shiqian committed
780

781
782
783
784
// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
// const T& and const T* in a function template.  These compilers
// _can_ decide between class template specializations for T and T*,
// so a tr1::type_traits-like is_pointer works.
785
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
786
#define GTEST_NEEDS_IS_POINTER_ 1
787
#endif
shiqian's avatar
shiqian committed
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804

template <bool bool_value>
struct bool_constant {
  typedef bool_constant<bool_value> type;
  static const bool value = bool_value;
};
template <bool bool_value> const bool bool_constant<bool_value>::value;

typedef bool_constant<false> false_type;
typedef bool_constant<true> true_type;

template <typename T>
struct is_pointer : public false_type {};

template <typename T>
struct is_pointer<T*> : public true_type {};

805
806
#if GTEST_OS_WINDOWS
#define GTEST_PATH_SEP_ "\\"
807
808
// The biggest signed integer type the compiler supports.
typedef __int64 BiggestInt;
809
810
#else
#define GTEST_PATH_SEP_ "/"
811
typedef long long BiggestInt;  // NOLINT
812
813
#endif  // GTEST_OS_WINDOWS

814
815
// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
816
817
818
819
// Windows/MSVC and POSIX systems.  Since some compilers define these
// standard functions as macros, the wrapper cannot have the same name
// as the wrapped function.

820
821
822
823
namespace posix {

// Functions with a different name on Windows.

zhanyong.wan's avatar
zhanyong.wan committed
824
#if GTEST_OS_WINDOWS
825

826
typedef struct _stat StatStruct;
827

828
829
830
831
832
833
#ifdef __BORLANDC__
inline int IsATTY(int fd) { return isatty(fd); }
inline int StrCaseCmp(const char* s1, const char* s2) {
  return stricmp(s1, s2);
}
inline char* StrDup(const char* src) { return strdup(src); }
834
#else  // !__BORLANDC__
835
#if GTEST_OS_WINDOWS_MOBILE
836
inline int IsATTY(int /* fd */) { return 0; }
837
#else
838
inline int IsATTY(int fd) { return _isatty(fd); }
839
#endif  // GTEST_OS_WINDOWS_MOBILE
840
841
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
842
}
843
inline char* StrDup(const char* src) { return _strdup(src); }
844
845
#endif  // __BORLANDC__

846
#if GTEST_OS_WINDOWS_MOBILE
847
848
849
inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
// time and thus not defined there.
850
#else
851
852
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
853
854
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
855
856
  return (_S_IFDIR & st.st_mode) != 0;
}
857
#endif  // GTEST_OS_WINDOWS_MOBILE
858

shiqian's avatar
shiqian committed
859
#else
860

861
typedef struct stat StatStruct;
862

863
864
865
866
867
868
inline int FileNo(FILE* file) { return fileno(file); }
inline int IsATTY(int fd) { return isatty(fd); }
inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
inline int StrCaseCmp(const char* s1, const char* s2) {
  return strcasecmp(s1, s2);
}
869
inline char* StrDup(const char* src) { return strdup(src); }
870
871
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
872

shiqian's avatar
shiqian committed
873
874
#endif  // GTEST_OS_WINDOWS

875
876
877
878
879
880
881
882
// Functions deprecated by MSVC 8.0.

#ifdef _MSC_VER
// Temporarily disable warning 4996 (deprecated function).
#pragma warning(push)
#pragma warning(disable:4996)
#endif

883
884
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
  return strncpy(dest, src, n);
885
}
886
887
888
889
890

// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
// StrError() aren't needed on Windows CE at this time and thus not
// defined there.

891
#if !GTEST_OS_WINDOWS_MOBILE
892
inline int ChDir(const char* dir) { return chdir(dir); }
893
#endif
894
895
inline FILE* FOpen(const char* path, const char* mode) {
  return fopen(path, mode);
896
}
897
#if !GTEST_OS_WINDOWS_MOBILE
898
899
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
900
}
901
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
902
#endif
903
inline int FClose(FILE* fp) { return fclose(fp); }
904
#if !GTEST_OS_WINDOWS_MOBILE
905
906
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
907
}
908
909
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
910
}
911
912
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
913
#endif
914
inline const char* GetEnv(const char* name) {
915
916
#if GTEST_OS_WINDOWS_MOBILE
  // We are on Windows CE, which has no environment variables.
917
  return NULL;
918
919
920
921
922
#elif defined(__BORLANDC__)
  // Environment variables which we programmatically clear will be set to the
  // empty string rather than unset (NULL).  Handle that case.
  const char* const env = getenv(name);
  return (env != NULL && env[0] != '\0') ? env : NULL;
923
#else
924
  return getenv(name);
925
926
927
928
929
930
931
#endif
}

#ifdef _MSC_VER
#pragma warning(pop)  // Restores the warning state.
#endif

932
#if GTEST_OS_WINDOWS_MOBILE
933
934
935
// Windows CE has no C library. The abort() function is used in
// several places in Google Test. This implementation provides a reasonable
// imitation of standard behaviour.
936
void Abort();
937
#else
938
inline void Abort() { abort(); }
939
#endif  // GTEST_OS_WINDOWS_MOBILE
940
941
942

}  // namespace posix

shiqian's avatar
shiqian committed
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
// The maximum number a BiggestInt can represent.  This definition
// works no matter BiggestInt is represented in one's complement or
// two's complement.
//
// We cannot rely on numeric_limits in STL, as __int64 and long long
// are not part of standard C++ and numeric_limits doesn't need to be
// defined for them.
const BiggestInt kMaxBiggestInt =
    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));

// This template class serves as a compile-time function from size to
// type.  It maps a size in bytes to a primitive type with that
// size. e.g.
//
//   TypeWithSize<4>::UInt
//
// is typedef-ed to be unsigned int (unsigned integer made up of 4
// bytes).
//
// Such functionality should belong to STL, but I cannot find it
// there.
//
// Google Test uses this class in the implementation of floating-point
// comparison.
//
// For now it only handles UInt (unsigned int) as that's all Google Test
// needs.  Other types can be easily added in the future if need
// arises.
template <size_t size>
class TypeWithSize {
 public:
  // This prevents the user from using TypeWithSize<N> with incorrect
  // values of N.
  typedef void UInt;
};

// The specialization for size 4.
template <>
class TypeWithSize<4> {
 public:
  // unsigned int has size 4 in both gcc and MSVC.
  //
  // As base/basictypes.h doesn't compile on Windows, we cannot use
  // uint32, uint64, and etc here.
  typedef int Int;
  typedef unsigned int UInt;
};

// The specialization for size 8.
template <>
class TypeWithSize<8> {
 public:
zhanyong.wan's avatar
zhanyong.wan committed
995
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
  typedef __int64 Int;
  typedef unsigned __int64 UInt;
#else
  typedef long long Int;  // NOLINT
  typedef unsigned long long UInt;  // NOLINT
#endif  // GTEST_OS_WINDOWS
};

// Integer types of known sizes.
typedef TypeWithSize<4>::Int Int32;
typedef TypeWithSize<4>::UInt UInt32;
typedef TypeWithSize<8>::Int Int64;
typedef TypeWithSize<8>::UInt UInt64;
typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.

// Utilities for command line flags and environment variables.

1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
// INTERNAL IMPLEMENTATION - DO NOT USE.
//
// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
// is not satisfied.
//  Synopsys:
//    GTEST_CHECK_(boolean_condition);
//     or
//    GTEST_CHECK_(boolean_condition) << "Additional message";
//
//    This checks the condition and if the condition is not satisfied
//    it prints message about the condition violation, including the
//    condition itself, plus additional message streamed into it, if any,
//    and then it aborts the program. It aborts the program irrespective of
//    whether it is built in the debug mode or not.
#define GTEST_CHECK_(condition) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1029
    if (::testing::internal::IsTrue(condition)) \
1030
1031
      ; \
    else \
1032
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1033

shiqian's avatar
shiqian committed
1034
1035
1036
1037
// Macro for referencing flags.
#define GTEST_FLAG(name) FLAGS_gtest_##name

// Macros for declaring flags.
shiqian's avatar
shiqian committed
1038
1039
#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
#define GTEST_DECLARE_int32_(name) \
shiqian's avatar
shiqian committed
1040
    extern ::testing::internal::Int32 GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1041
#define GTEST_DECLARE_string_(name) \
shiqian's avatar
shiqian committed
1042
1043
1044
    extern ::testing::internal::String GTEST_FLAG(name)

// Macros for defining flags.
shiqian's avatar
shiqian committed
1045
#define GTEST_DEFINE_bool_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1046
    bool GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1047
#define GTEST_DEFINE_int32_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1048
    ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1049
#define GTEST_DEFINE_string_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
    ::testing::internal::String GTEST_FLAG(name) = (default_val)

// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
// to *value and returns true; otherwise leaves *value unchanged and returns
// false.
// TODO(chandlerc): Find a better way to refactor flag and environment parsing
// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
// function.
bool ParseInt32(const Message& src_text, const char* str, Int32* value);

// Parses a bool/Int32/string from the environment variable
// corresponding to the given Google Test flag.
bool BoolFromGTestEnv(const char* flag, bool default_val);
Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
const char* StringFromGTestEnv(const char* flag, const char* default_val);

}  // namespace internal
}  // namespace testing

#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_