gtest-port.h 37.1 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.
45
46
//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
//                              are enabled.
shiqian's avatar
shiqian committed
47
48
49
50
51
52
//   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
53
54
//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
//                              is/isn't available.
55
56
57
58
59
//   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).
60
//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
61
//                              is/isn't available.
62
63
64
//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
//                              compiler supports Microsoft's "Structured
//                              Exception Handling".
65
66
67
68
//   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
69
70
71

// This header defines the following utilities:
//
zhanyong.wan's avatar
zhanyong.wan committed
72
73
74
75
76
77
78
// 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
79
80
81
//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
//     GTEST_OS_WINDOWS_MINGW    - MinGW
82
//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
zhanyong.wan's avatar
zhanyong.wan committed
83
//   GTEST_OS_ZOS      - z/OS
84
//
85
86
87
88
89
90
91
// 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
92
// Note that it is possible that none of the GTEST_OS_* macros are defined.
shiqian's avatar
shiqian committed
93
//
zhanyong.wan's avatar
zhanyong.wan committed
94
95
96
97
98
99
100
101
102
103
// 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;
104
//                            the above two are mutually exclusive.
shiqian's avatar
shiqian committed
105
106
//
// Macros for basic C++ coding:
shiqian's avatar
shiqian committed
107
//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
108
109
//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
//                              variable don't have to be used.
110
//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
shiqian's avatar
shiqian committed
111
112
//   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
113
114
115
116
//
// Synchronization:
//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
//                  - synchronization primitives.
shiqian's avatar
shiqian committed
117
118
119
//   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
120
121
//
// Template meta programming:
122
//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
shiqian's avatar
shiqian committed
123
124
125
126
127
128
129
130
131
132
//
// 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
133
//   GTEST_LOG_()   - logs messages at the specified severity level.
shiqian's avatar
shiqian committed
134
135
136
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.
//
137
138
139
140
// Stdout and stderr capturing:
//   CaptureStdout()     - starts capturing stdout.
//   GetCapturedStdout() - stops capturing stdout and returns the captured
//                         string.
shiqian's avatar
shiqian committed
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
//   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.

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

#include <iostream>  // NOLINT
172
173
#include <sstream>  // NOLINT
#include <string>  // NOLINT
shiqian's avatar
shiqian committed
174

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

shiqian's avatar
shiqian committed
182
183
184
185
186
187
188
// 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
189
// Determines the platform on which Google Test is compiled.
190
#ifdef __CYGWIN__
zhanyong.wan's avatar
zhanyong.wan committed
191
#define GTEST_OS_CYGWIN 1
192
#elif defined __SYMBIAN32__
zhanyong.wan's avatar
zhanyong.wan committed
193
#define GTEST_OS_SYMBIAN 1
194
#elif defined _WIN32
zhanyong.wan's avatar
zhanyong.wan committed
195
#define GTEST_OS_WINDOWS 1
196
197
198
199
200
201
202
#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
203
#elif defined __APPLE__
zhanyong.wan's avatar
zhanyong.wan committed
204
#define GTEST_OS_MAC 1
shiqian's avatar
shiqian committed
205
#elif defined __linux__
zhanyong.wan's avatar
zhanyong.wan committed
206
#define GTEST_OS_LINUX 1
207
#elif defined __MVS__
zhanyong.wan's avatar
zhanyong.wan committed
208
#define GTEST_OS_ZOS 1
209
#elif defined(__sun) && defined(__SVR4)
zhanyong.wan's avatar
zhanyong.wan committed
210
#define GTEST_OS_SOLARIS 1
211
#endif  // __CYGWIN__
shiqian's avatar
shiqian committed
212

213
214
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
    GTEST_OS_SOLARIS
215
216
217
218
219
220

// 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
221
222
223
224
#include <strings.h>  // NOLINT
#include <sys/types.h>  // NOLINT
#include <unistd.h>  // NOLINT

225
226
#define GTEST_USES_POSIX_RE 1

227
228
#elif GTEST_OS_WINDOWS

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

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

238
239
#else

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

244
245
#endif  // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
        // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
246

247
248
249
#ifndef GTEST_HAS_EXCEPTIONS
// The user didn't tell us whether exceptions are enabled, so we need
// to figure it out.
250
251
252
#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
253
// Assumes that exceptions are enabled by default.
254
#ifndef _HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
255
256
257
#define _HAS_EXCEPTIONS 1
#endif  // _HAS_EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
258
259
260
261
262
263
264
#elif defined(__GNUC__) && __EXCEPTIONS
// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
#define GTEST_HAS_EXCEPTIONS 1
#elif defined(__SUNPRO_CC)
// Sun Pro CC supports exceptions.  However, there is no compile-time way of
// detecting whether they are enabled or not.  Therefore, we assume that
// they are enabled unless the user tells us otherwise.
265
266
#define GTEST_HAS_EXCEPTIONS 1
#else
267
268
// For other compilers, we assume exceptions are disabled to be
// conservative.
269
#define GTEST_HAS_EXCEPTIONS 0
270
#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
271
#endif  // GTEST_HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
272

273
274
275
#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.
276
#define GTEST_HAS_STD_STRING 1
277
278
279
280
#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
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295

#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.

296
297
// Cygwin 1.5 and below doesn't support ::std::wstring.
// Cygwin 1.7 might add wstring support; this should be updated when clear.
298
// Solaris' libc++ doesn't support it either.
299
#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
shiqian's avatar
shiqian committed
300
301
302
303
304
305

#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.
306
307
#define GTEST_HAS_GLOBAL_WSTRING \
    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
shiqian's avatar
shiqian committed
308
309
#endif  // GTEST_HAS_GLOBAL_WSTRING

shiqian's avatar
shiqian committed
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
340
341
342
343
344
345
// 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
346
347
348
// Determines whether <pthread.h> is available.
#ifndef GTEST_HAS_PTHREAD
// The user didn't tell us, so we need to figure it out.
349
#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SOLARIS)
shiqian's avatar
shiqian committed
350
351
#endif  // GTEST_HAS_PTHREAD

352
353
354
// 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).
355
#ifndef GTEST_HAS_TR1_TUPLE
356
357
358
359
360
361
362
// 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
363
364
// The user didn't tell us, so we need to figure it out.

365
// We use our own TR1 tuple if we aren't sure the user has an
366
367
// 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
368
369
// implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
// defining __GNUC__ and friends, but cannot compile GCC's tuple
370
371
// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
// Feature Pack download, which we cannot assume the user has.
372
373
#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
    || _MSC_VER >= 1600
374
#define GTEST_USE_OWN_TR1_TUPLE 0
375
#else
376
#define GTEST_USE_OWN_TR1_TUPLE 1
377
#endif
378
379

#endif  // GTEST_USE_OWN_TR1_TUPLE
380

381
382
383
384
// 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
385

386
387
388
#if GTEST_USE_OWN_TR1_TUPLE
#include <gtest/internal/gtest-tuple.h>
#elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404

// 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)
405
406
// 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>.
407
408
409
410
411
412
413
414
415
416
417
418

#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
419
#include <tr1/tuple>  // NOLINT
420
421
#endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

422
#else
423
// If the compiler is not GCC 4.0+, we assume the user is using a
424
// spec-conforming TR1 implementation.
425
#include <tuple>  // NOLINT
426
#endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
427

428
429
#endif  // GTEST_HAS_TR1_TUPLE

430
431
432
433
434
435
436
// 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
437
#if GTEST_OS_LINUX && !defined(__ia64__)
438
439
440
#define GTEST_HAS_CLONE 1
#else
#define GTEST_HAS_CLONE 0
zhanyong.wan's avatar
zhanyong.wan committed
441
#endif  // GTEST_OS_LINUX && !defined(__ia64__)
442
443
444

#endif  // GTEST_HAS_CLONE

445
446
447
448
449
450
// Determines whether to support stream redirection. This is used to test
// output correctness and to implement death tests.
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
#define GTEST_HAS_STREAM_REDIRECTION_ 1
#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN

shiqian's avatar
shiqian committed
451
// Determines whether to support death tests.
452
453
454
// 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.
455
#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
456
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
zhanyong.wan's avatar
zhanyong.wan committed
457
#define GTEST_HAS_DEATH_TEST 1
458
#include <vector>  // NOLINT
459
#endif
shiqian's avatar
shiqian committed
460

461
462
463
464
465
// 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
466
#define GTEST_HAS_PARAM_TEST 1
467
468
#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)

469
470
// Determines whether to support type-driven tests.

471
472
473
// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, and
// Sun Pro CC support.
#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC)
474
475
#define GTEST_HAS_TYPED_TEST 1
#define GTEST_HAS_TYPED_TEST_P 1
476
#endif
477

478
479
// Determines whether to support Combine(). This only makes sense when
// value-parameterized tests are enabled.
zhanyong.wan's avatar
zhanyong.wan committed
480
481
482
#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
#define GTEST_HAS_COMBINE 1
#endif  // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
483

484
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
zhanyong.wan's avatar
zhanyong.wan committed
485
486
#define GTEST_WIDE_STRING_USES_UTF16_ \
    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
487

shiqian's avatar
shiqian committed
488
489
490
491
492
493
494
495
496
497
498
// 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
499
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
shiqian's avatar
shiqian committed
500
#else
shiqian's avatar
shiqian committed
501
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0:  // NOLINT
shiqian's avatar
shiqian committed
502
503
#endif

504
// Use this annotation at the end of a struct/class definition to
shiqian's avatar
shiqian committed
505
506
507
508
509
510
// 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
511
//   } GTEST_ATTRIBUTE_UNUSED_;
512
513
514
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
515
#if defined(__GNUC__) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
516
#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
517
#else
shiqian's avatar
shiqian committed
518
#define GTEST_ATTRIBUTE_UNUSED_
519
#endif
shiqian's avatar
shiqian committed
520

521
522
523
524
525
526
// 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
527
// This should be used in the private: declarations for a class.
shiqian's avatar
shiqian committed
528
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
529
530
  type(type const &);\
  GTEST_DISALLOW_ASSIGN_(type)
shiqian's avatar
shiqian committed
531
532
533
534
535

// 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
536
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
537
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
538
#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
shiqian's avatar
shiqian committed
539
#else
shiqian's avatar
shiqian committed
540
#define GTEST_MUST_USE_RESULT_
shiqian's avatar
shiqian committed
541
#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
shiqian's avatar
shiqian committed
542

543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
// 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
559
560
561
562
563
564
565
566
567
568
namespace testing {

class Message;

namespace internal {

class String;

typedef ::std::stringstream StrStream;

569
570
571
572
// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
bool IsTrue(bool condition);

shiqian's avatar
shiqian committed
573
574
575
576
577
578
579
// 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:
580
581
  typedef T element_type;

shiqian's avatar
shiqian committed
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
  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_) {
597
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
shiqian's avatar
shiqian committed
598
599
600
601
602
603
604
605
        delete ptr_;
      }
      ptr_ = p;
    }
  }
 private:
  T* ptr_;

shiqian's avatar
shiqian committed
606
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
607
608
};

609
// Defines RE.
shiqian's avatar
shiqian committed
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627

// 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_; }

628
629
630
631
632
633
634
635
636
637
  // 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
638
639
640
641
642
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

#if GTEST_HAS_GLOBAL_STRING
643
644
645
  static bool FullMatch(const ::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
646
647
648
649
650
  static bool PartialMatch(const ::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }
#endif  // GTEST_HAS_GLOBAL_STRING

651
  static bool FullMatch(const char* str, const RE& re);
shiqian's avatar
shiqian committed
652
653
654
655
656
657
658
659
660
661
  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_;
662
663
  bool is_valid_;
#if GTEST_USES_POSIX_RE
664
665
  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().
666
667
668
#else  // GTEST_USES_SIMPLE_RE
  const char* full_pattern_;  // For FullMatch();
#endif
shiqian's avatar
shiqian committed
669

670
671
  GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
};
shiqian's avatar
shiqian committed
672
673

// Defines logging utilities:
674
675
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
shiqian's avatar
shiqian committed
676
677
678
679
680
681
682
683
684
685
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

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

686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
// 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
703

704
705
706
#define GTEST_LOG_(severity) \
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()
shiqian's avatar
shiqian committed
707
708
709
710

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

711
#if GTEST_HAS_STREAM_REDIRECTION_
712

shiqian's avatar
shiqian committed
713
// Defines the stderr capturer:
714
715
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
shiqian's avatar
shiqian committed
716
717
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
718
719
720
//
void CaptureStdout();
String GetCapturedStdout();
721
void CaptureStderr();
722
String GetCapturedStderr();
723

724
#endif  // GTEST_HAS_STREAM_REDIRECTION_
725
726


zhanyong.wan's avatar
zhanyong.wan committed
727
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746

// 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() {}
747
  explicit Mutex(int /*unused*/) {}
shiqian's avatar
shiqian committed
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
  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
765
766
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
767
768
769
770
771
772
773
774
  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_;
};

775
776
777
// 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
778

shiqian's avatar
shiqian committed
779
780
781
782
// The above synchronization primitives have dummy implementations.
// Therefore Google Test is not thread-safe.
#define GTEST_IS_THREADSAFE 0

783
// Passing non-POD classes through ellipsis (...) crashes the ARM
784
785
786
787
788
789
790
791
// 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
792

793
794
795
796
// 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.
797
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
798
#define GTEST_NEEDS_IS_POINTER_ 1
799
#endif
shiqian's avatar
shiqian committed
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816

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 {};

817
818
#if GTEST_OS_WINDOWS
#define GTEST_PATH_SEP_ "\\"
819
#define GTEST_HAS_ALT_PATH_SEP_ 1
820
821
// The biggest signed integer type the compiler supports.
typedef __int64 BiggestInt;
822
823
#else
#define GTEST_PATH_SEP_ "/"
824
#define GTEST_HAS_ALT_PATH_SEP_ 0
825
typedef long long BiggestInt;  // NOLINT
826
827
#endif  // GTEST_OS_WINDOWS

828
829
// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
830
831
832
833
// 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.

834
835
836
837
namespace posix {

// Functions with a different name on Windows.

zhanyong.wan's avatar
zhanyong.wan committed
838
#if GTEST_OS_WINDOWS
839

840
typedef struct _stat StatStruct;
841

842
843
844
845
846
847
#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); }
848
#else  // !__BORLANDC__
849
#if GTEST_OS_WINDOWS_MOBILE
850
inline int IsATTY(int /* fd */) { return 0; }
851
#else
852
inline int IsATTY(int fd) { return _isatty(fd); }
853
#endif  // GTEST_OS_WINDOWS_MOBILE
854
855
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
856
}
857
inline char* StrDup(const char* src) { return _strdup(src); }
858
859
#endif  // __BORLANDC__

860
#if GTEST_OS_WINDOWS_MOBILE
861
862
863
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.
864
#else
865
866
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
867
868
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
869
870
  return (_S_IFDIR & st.st_mode) != 0;
}
871
#endif  // GTEST_OS_WINDOWS_MOBILE
872

shiqian's avatar
shiqian committed
873
#else
874

875
typedef struct stat StatStruct;
876

877
878
879
880
881
882
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);
}
883
inline char* StrDup(const char* src) { return strdup(src); }
884
885
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
886

shiqian's avatar
shiqian committed
887
888
#endif  // GTEST_OS_WINDOWS

889
890
891
892
893
894
895
896
// Functions deprecated by MSVC 8.0.

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

897
898
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
  return strncpy(dest, src, n);
899
}
900
901
902
903
904

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

905
#if !GTEST_OS_WINDOWS_MOBILE
906
inline int ChDir(const char* dir) { return chdir(dir); }
907
#endif
908
909
inline FILE* FOpen(const char* path, const char* mode) {
  return fopen(path, mode);
910
}
911
#if !GTEST_OS_WINDOWS_MOBILE
912
913
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
914
}
915
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
916
#endif
917
inline int FClose(FILE* fp) { return fclose(fp); }
918
#if !GTEST_OS_WINDOWS_MOBILE
919
920
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
921
}
922
923
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
924
}
925
926
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
927
#endif
928
inline const char* GetEnv(const char* name) {
929
930
#if GTEST_OS_WINDOWS_MOBILE
  // We are on Windows CE, which has no environment variables.
931
  return NULL;
932
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
933
934
935
936
  // 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;
937
#else
938
  return getenv(name);
939
940
941
942
943
944
945
#endif
}

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

946
#if GTEST_OS_WINDOWS_MOBILE
947
948
949
// 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.
950
void Abort();
951
#else
952
inline void Abort() { abort(); }
953
#endif  // GTEST_OS_WINDOWS_MOBILE
954
955
956

}  // namespace posix

shiqian's avatar
shiqian committed
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
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
// 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
1009
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
  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.

1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
// 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_ \
1043
    if (::testing::internal::IsTrue(condition)) \
1044
1045
      ; \
    else \
1046
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1047

shiqian's avatar
shiqian committed
1048
1049
1050
1051
// Macro for referencing flags.
#define GTEST_FLAG(name) FLAGS_gtest_##name

// Macros for declaring flags.
shiqian's avatar
shiqian committed
1052
1053
#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
#define GTEST_DECLARE_int32_(name) \
shiqian's avatar
shiqian committed
1054
    extern ::testing::internal::Int32 GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1055
#define GTEST_DECLARE_string_(name) \
shiqian's avatar
shiqian committed
1056
1057
1058
    extern ::testing::internal::String GTEST_FLAG(name)

// Macros for defining flags.
shiqian's avatar
shiqian committed
1059
#define GTEST_DEFINE_bool_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1060
    bool GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1061
#define GTEST_DEFINE_int32_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1062
    ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1063
#define GTEST_DEFINE_string_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
    ::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_