gtest-port.h 35.7 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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.
//
// Stderr capturing:
//   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.

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

#include <iostream>  // NOLINT
167
168
#include <sstream>  // NOLINT
#include <string>  // NOLINT
shiqian's avatar
shiqian committed
169

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

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

208
209
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
    GTEST_OS_SOLARIS
210
211
212
213
214
215

// 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
216
217
218
219
#include <strings.h>  // NOLINT
#include <sys/types.h>  // NOLINT
#include <unistd.h>  // NOLINT

220
221
#define GTEST_USES_POSIX_RE 1

222
223
#elif GTEST_OS_WINDOWS

224
#if !GTEST_OS_WINDOWS_MOBILE
225
226
#include <direct.h>  // NOLINT
#include <io.h>  // NOLINT
227
#endif
228
229
230
231
232

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

233
234
#else

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

239
240
#endif  // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
        // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
241

242
243
// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0
// otherwise.
shiqian's avatar
shiqian committed
244

245
246
247
#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
248
// Assumes that exceptions are enabled by default.
249
#ifndef _HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
250
251
252
#define _HAS_EXCEPTIONS 1
#endif  // _HAS_EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
253
#else  // The compiler is not MSVC or C++Builder.
254
255
256
// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.  For
// other compilers, we assume exceptions are disabled to be
// conservative.
257
258
259
260
261
#if defined(__GNUC__) && __EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS 1
#else
#define GTEST_HAS_EXCEPTIONS 0
#endif  // defined(__GNUC__) && __EXCEPTIONS
262
#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
shiqian's avatar
shiqian committed
263

264
265
266
#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.
267
#define GTEST_HAS_STD_STRING 1
268
269
270
271
#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
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

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

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

#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.
297
298
#define GTEST_HAS_GLOBAL_WSTRING \
    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
shiqian's avatar
shiqian committed
299
300
#endif  // GTEST_HAS_GLOBAL_WSTRING

shiqian's avatar
shiqian committed
301
302
303
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
// 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
337
338
339
// 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
340
#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC)
shiqian's avatar
shiqian committed
341
342
#endif  // GTEST_HAS_PTHREAD

343
344
345
// 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).
346
#ifndef GTEST_HAS_TR1_TUPLE
347
348
349
350
351
352
353
// 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
354
355
// The user didn't tell us, so we need to figure it out.

356
// We use our own tr1 tuple if we aren't sure the user has an
357
358
359
360
// 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
// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
// Feature Pack download, which we cannot assume the user has.
361
#if (defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)) || _MSC_VER >= 1600
362
#define GTEST_USE_OWN_TR1_TUPLE 0
363
#else
364
#define GTEST_USE_OWN_TR1_TUPLE 1
365
#endif
366
367

#endif  // GTEST_USE_OWN_TR1_TUPLE
368

369
370
371
372
// 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
373

374
375
376
#if GTEST_USE_OWN_TR1_TUPLE
#include <gtest/internal/gtest-tuple.h>
#elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392

// 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)
393
394
// 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>.
395
396
397
398
399
400
401
402
403
404
405
406

#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
407
#include <tr1/tuple>  // NOLINT
408
409
#endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

410
#else
411
// If the compiler is not GCC 4.0+, we assume the user is using a
412
// spec-conforming TR1 implementation.
413
#include <tuple>  // NOLINT
414
#endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
415

416
417
#endif  // GTEST_HAS_TR1_TUPLE

418
419
420
421
422
423
424
// 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
425
#if GTEST_OS_LINUX && !defined(__ia64__)
426
427
428
#define GTEST_HAS_CLONE 1
#else
#define GTEST_HAS_CLONE 0
zhanyong.wan's avatar
zhanyong.wan committed
429
#endif  // GTEST_OS_LINUX && !defined(__ia64__)
430
431
432

#endif  // GTEST_HAS_CLONE

shiqian's avatar
shiqian committed
433
// Determines whether to support death tests.
434
435
436
437
// 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 || \
438
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
zhanyong.wan's avatar
zhanyong.wan committed
439
#define GTEST_HAS_DEATH_TEST 1
440
#include <vector>  // NOLINT
441
#endif
shiqian's avatar
shiqian committed
442

443
444
445
446
447
// 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
448
#define GTEST_HAS_PARAM_TEST 1
449
450
#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)

451
452
453
454
455
// 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)
456
457
#define GTEST_HAS_TYPED_TEST 1
#define GTEST_HAS_TYPED_TEST_P 1
458
459
#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)

460
461
// Determines whether to support Combine(). This only makes sense when
// value-parameterized tests are enabled.
zhanyong.wan's avatar
zhanyong.wan committed
462
463
464
#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
#define GTEST_HAS_COMBINE 1
#endif  // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
465

466
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
zhanyong.wan's avatar
zhanyong.wan committed
467
468
#define GTEST_WIDE_STRING_USES_UTF16_ \
    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
469

shiqian's avatar
shiqian committed
470
471
472
473
474
475
476
477
478
479
480
// 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
481
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
shiqian's avatar
shiqian committed
482
#else
shiqian's avatar
shiqian committed
483
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0:  // NOLINT
shiqian's avatar
shiqian committed
484
485
#endif

486
// Use this annotation at the end of a struct/class definition to
shiqian's avatar
shiqian committed
487
488
489
490
491
492
// 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
493
//   } GTEST_ATTRIBUTE_UNUSED_;
494
495
496
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
497
#if defined(__GNUC__) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
498
#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
499
#else
shiqian's avatar
shiqian committed
500
#define GTEST_ATTRIBUTE_UNUSED_
501
#endif
shiqian's avatar
shiqian committed
502

503
504
505
506
507
508
// 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
509
// This should be used in the private: declarations for a class.
shiqian's avatar
shiqian committed
510
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
511
512
  type(type const &);\
  GTEST_DISALLOW_ASSIGN_(type)
shiqian's avatar
shiqian committed
513
514
515
516
517

// 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
518
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
519
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
520
#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
shiqian's avatar
shiqian committed
521
#else
shiqian's avatar
shiqian committed
522
#define GTEST_MUST_USE_RESULT_
shiqian's avatar
shiqian committed
523
#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
shiqian's avatar
shiqian committed
524

525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
// 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
541
542
543
544
545
546
547
548
549
550
namespace testing {

class Message;

namespace internal {

class String;

typedef ::std::stringstream StrStream;

551
552
553
554
// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
bool IsTrue(bool condition);

shiqian's avatar
shiqian committed
555
556
557
558
559
560
561
// 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:
562
563
  typedef T element_type;

shiqian's avatar
shiqian committed
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
  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_) {
579
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
shiqian's avatar
shiqian committed
580
581
582
583
584
585
586
587
        delete ptr_;
      }
      ptr_ = p;
    }
  }
 private:
  T* ptr_;

shiqian's avatar
shiqian committed
588
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
589
590
};

591
// Defines RE.
shiqian's avatar
shiqian committed
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609

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

610
611
612
613
614
615
616
617
618
619
  // 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
620
621
622
623
624
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

#if GTEST_HAS_GLOBAL_STRING
625
626
627
  static bool FullMatch(const ::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
628
629
630
631
632
  static bool PartialMatch(const ::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }
#endif  // GTEST_HAS_GLOBAL_STRING

633
  static bool FullMatch(const char* str, const RE& re);
shiqian's avatar
shiqian committed
634
635
636
637
638
639
640
641
642
643
  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_;
644
645
  bool is_valid_;
#if GTEST_USES_POSIX_RE
646
647
  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().
648
649
650
#else  // GTEST_USES_SIMPLE_RE
  const char* full_pattern_;  // For FullMatch();
#endif
shiqian's avatar
shiqian committed
651

652
653
  GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
};
shiqian's avatar
shiqian committed
654
655

// Defines logging utilities:
656
657
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
shiqian's avatar
shiqian committed
658
659
660
661
662
663
664
665
666
667
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

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

668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
// 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
685

686
687
688
#define GTEST_LOG_(severity) \
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()
shiqian's avatar
shiqian committed
689
690
691
692
693
694
695
696

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

// Defines the stderr capturer:
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.

697
void CaptureStderr();
698
String GetCapturedStderr();
699

zhanyong.wan's avatar
zhanyong.wan committed
700
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719

// 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() {}
720
  explicit Mutex(int /*unused*/) {}
shiqian's avatar
shiqian committed
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
  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
738
739
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
740
741
742
743
744
745
746
747
  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_;
};

748
749
750
// 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
751

shiqian's avatar
shiqian committed
752
753
754
755
// The above synchronization primitives have dummy implementations.
// Therefore Google Test is not thread-safe.
#define GTEST_IS_THREADSAFE 0

756
// Passing non-POD classes through ellipsis (...) crashes the ARM
757
758
759
760
761
762
763
764
// 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
765

766
767
768
769
// 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.
770
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
771
#define GTEST_NEEDS_IS_POINTER_ 1
772
#endif
shiqian's avatar
shiqian committed
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789

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

790
791
#if GTEST_OS_WINDOWS
#define GTEST_PATH_SEP_ "\\"
792
793
// The biggest signed integer type the compiler supports.
typedef __int64 BiggestInt;
794
795
#else
#define GTEST_PATH_SEP_ "/"
796
typedef long long BiggestInt;  // NOLINT
797
798
#endif  // GTEST_OS_WINDOWS

799
800
// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
801
802
803
804
// 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.

805
806
807
808
namespace posix {

// Functions with a different name on Windows.

zhanyong.wan's avatar
zhanyong.wan committed
809
#if GTEST_OS_WINDOWS
810

811
typedef struct _stat StatStruct;
812

813
814
815
816
817
818
#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); }
819
#else  // !__BORLANDC__
820
#if GTEST_OS_WINDOWS_MOBILE
821
inline int IsATTY(int /* fd */) { return 0; }
822
#else
823
inline int IsATTY(int fd) { return _isatty(fd); }
824
#endif  // GTEST_OS_WINDOWS_MOBILE
825
826
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
827
}
828
inline char* StrDup(const char* src) { return _strdup(src); }
829
830
#endif  // __BORLANDC__

831
#if GTEST_OS_WINDOWS_MOBILE
832
833
834
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.
835
#else
836
837
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
838
839
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
840
841
  return (_S_IFDIR & st.st_mode) != 0;
}
842
#endif  // GTEST_OS_WINDOWS_MOBILE
843

shiqian's avatar
shiqian committed
844
#else
845

846
typedef struct stat StatStruct;
847

848
849
850
851
852
853
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);
}
854
inline char* StrDup(const char* src) { return strdup(src); }
855
856
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
857

shiqian's avatar
shiqian committed
858
859
#endif  // GTEST_OS_WINDOWS

860
861
862
863
864
865
866
867
// Functions deprecated by MSVC 8.0.

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

868
869
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
  return strncpy(dest, src, n);
870
}
871
872
873
874
875

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

876
#if !GTEST_OS_WINDOWS_MOBILE
877
inline int ChDir(const char* dir) { return chdir(dir); }
878
#endif
879
880
inline FILE* FOpen(const char* path, const char* mode) {
  return fopen(path, mode);
881
}
882
#if !GTEST_OS_WINDOWS_MOBILE
883
884
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
885
}
886
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
887
#endif
888
inline int FClose(FILE* fp) { return fclose(fp); }
889
#if !GTEST_OS_WINDOWS_MOBILE
890
891
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
892
}
893
894
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
895
}
896
897
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
898
#endif
899
inline const char* GetEnv(const char* name) {
900
901
#if GTEST_OS_WINDOWS_MOBILE
  // We are on Windows CE, which has no environment variables.
902
  return NULL;
903
904
905
906
907
#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;
908
#else
909
  return getenv(name);
910
911
912
913
914
915
916
#endif
}

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

917
#if GTEST_OS_WINDOWS_MOBILE
918
919
920
// 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.
921
void Abort();
922
#else
923
inline void Abort() { abort(); }
924
#endif  // GTEST_OS_WINDOWS_MOBILE
925
926
927

}  // namespace posix

shiqian's avatar
shiqian committed
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
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
// 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
980
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
  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.

998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
// 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_ \
1014
    if (::testing::internal::IsTrue(condition)) \
1015
1016
      ; \
    else \
1017
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1018

shiqian's avatar
shiqian committed
1019
1020
1021
1022
// Macro for referencing flags.
#define GTEST_FLAG(name) FLAGS_gtest_##name

// Macros for declaring flags.
shiqian's avatar
shiqian committed
1023
1024
#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
#define GTEST_DECLARE_int32_(name) \
shiqian's avatar
shiqian committed
1025
    extern ::testing::internal::Int32 GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1026
#define GTEST_DECLARE_string_(name) \
shiqian's avatar
shiqian committed
1027
1028
1029
    extern ::testing::internal::String GTEST_FLAG(name)

// Macros for defining flags.
shiqian's avatar
shiqian committed
1030
#define GTEST_DEFINE_bool_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1031
    bool GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1032
#define GTEST_DEFINE_int32_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1033
    ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1034
#define GTEST_DEFINE_string_(name, default_val, doc) \
shiqian's avatar
shiqian committed
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
    ::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_