gtest-port.h 46.5 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.
69
70
71
72
73
74
75
//   GTEST_LINKED_AS_SHARED_LIBRARY
//                            - Define to 1 when compiling tests that use
//                              Google Test as a shared library (known as
//                              DLL on Windows).
//   GTEST_CREATE_SHARED_LIBRARY
//                            - Define to 1 when compiling Google Test itself
//                              as a shared library.
shiqian's avatar
shiqian committed
76
77
78

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

170
#include <stddef.h>  // For ptrdiff_t
shiqian's avatar
shiqian committed
171
172
#include <stdlib.h>
#include <stdio.h>
173
#include <string.h>
174
#ifndef _WIN32_WCE
175
#include <sys/stat.h>
176
#endif  // !_WIN32_WCE
177
178

#include <iostream>  // NOLINT
179
180
#include <sstream>  // NOLINT
#include <string>  // NOLINT
shiqian's avatar
shiqian committed
181

182
#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
zhanyong.wan's avatar
zhanyong.wan committed
183
#define GTEST_FLAG_PREFIX_ "gtest_"
184
#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
zhanyong.wan's avatar
zhanyong.wan committed
185
#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
186
187
#define GTEST_NAME_ "Google Test"
#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
shiqian's avatar
shiqian committed
188

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

220
221
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \
    GTEST_OS_SOLARIS
222
223
224
225
226
227

// 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
228
229
#include <strings.h>  // NOLINT
#include <sys/types.h>  // NOLINT
230
#include <time.h>  // NOLINT
231
232
#include <unistd.h>  // NOLINT

233
234
#define GTEST_USES_POSIX_RE 1

235
236
#elif GTEST_OS_WINDOWS

237
#if !GTEST_OS_WINDOWS_MOBILE
238
239
#include <direct.h>  // NOLINT
#include <io.h>  // NOLINT
240
#endif
241
242
243
244
245

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

246
247
#else

248
249
// <regex.h> may not be available on this platform.  Use our own
// simple regex implementation instead.
250
251
#define GTEST_USES_SIMPLE_RE 1

252
253
#endif  // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC ||
        // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS
254

255
256
257
#ifndef GTEST_HAS_EXCEPTIONS
// The user didn't tell us whether exceptions are enabled, so we need
// to figure it out.
258
259
260
#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
261
// Assumes that exceptions are enabled by default.
262
#ifndef _HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
263
264
265
#define _HAS_EXCEPTIONS 1
#endif  // _HAS_EXCEPTIONS
#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
266
267
268
269
270
271
272
#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.
273
274
#define GTEST_HAS_EXCEPTIONS 1
#else
275
276
// For other compilers, we assume exceptions are disabled to be
// conservative.
277
#define GTEST_HAS_EXCEPTIONS 0
278
#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
279
#endif  // GTEST_HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
280

281
282
283
#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.
284
#define GTEST_HAS_STD_STRING 1
285
286
287
288
#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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303

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

304
305
// Cygwin 1.5 and below doesn't support ::std::wstring.
// Cygwin 1.7 might add wstring support; this should be updated when clear.
306
// Solaris' libc++ doesn't support it either.
307
#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
shiqian's avatar
shiqian committed
308
309
310
311
312
313

#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.
314
315
#define GTEST_HAS_GLOBAL_WSTRING \
    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
shiqian's avatar
shiqian committed
316
317
#endif  // GTEST_HAS_GLOBAL_WSTRING

shiqian's avatar
shiqian committed
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
346
347
348
349
350
351
352
353
// 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

354
// Determines whether Google Test can use the pthreads library.
shiqian's avatar
shiqian committed
355
#ifndef GTEST_HAS_PTHREAD
356
357
358
359
360
361
// The user didn't tell us explicitly, so we assume pthreads support is
// available on Linux and Mac.
//
// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
// to your compiler flags.
#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC)
shiqian's avatar
shiqian committed
362
363
#endif  // GTEST_HAS_PTHREAD

364
365
366
// 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).
367
#ifndef GTEST_HAS_TR1_TUPLE
368
369
370
371
372
373
374
// 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
375
376
// The user didn't tell us, so we need to figure it out.

377
// We use our own TR1 tuple if we aren't sure the user has an
378
379
// 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
380
381
// implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
// defining __GNUC__ and friends, but cannot compile GCC's tuple
382
383
// implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
// Feature Pack download, which we cannot assume the user has.
384
385
#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
    || _MSC_VER >= 1600
386
#define GTEST_USE_OWN_TR1_TUPLE 0
387
#else
388
#define GTEST_USE_OWN_TR1_TUPLE 1
389
#endif
390
391

#endif  // GTEST_USE_OWN_TR1_TUPLE
392

393
394
395
396
// 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
397

398
399
400
#if GTEST_USE_OWN_TR1_TUPLE
#include <gtest/internal/gtest-tuple.h>
#elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416

// 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)
417
418
// 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>.
419
420
421
422
423
424
425
426
427
428
429
430

#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
431
#include <tr1/tuple>  // NOLINT
432
433
#endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

434
#else
435
// If the compiler is not GCC 4.0+, we assume the user is using a
436
// spec-conforming TR1 implementation.
437
#include <tuple>  // NOLINT
438
#endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
439

440
441
#endif  // GTEST_HAS_TR1_TUPLE

442
443
444
445
446
447
448
// 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
449
#if GTEST_OS_LINUX && !defined(__ia64__)
450
451
452
#define GTEST_HAS_CLONE 1
#else
#define GTEST_HAS_CLONE 0
zhanyong.wan's avatar
zhanyong.wan committed
453
#endif  // GTEST_OS_LINUX && !defined(__ia64__)
454
455
456

#endif  // GTEST_HAS_CLONE

457
458
459
460
461
462
// 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
463
// Determines whether to support death tests.
464
465
466
// 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.
467
#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
468
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW)
zhanyong.wan's avatar
zhanyong.wan committed
469
#define GTEST_HAS_DEATH_TEST 1
470
#include <vector>  // NOLINT
471
#endif
shiqian's avatar
shiqian committed
472

473
474
475
// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
// all the compilers we care about are adequate for supporting
// value-parameterized tests.
zhanyong.wan's avatar
zhanyong.wan committed
476
#define GTEST_HAS_PARAM_TEST 1
477

478
479
// Determines whether to support type-driven tests.

480
481
482
// 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)
483
484
#define GTEST_HAS_TYPED_TEST 1
#define GTEST_HAS_TYPED_TEST_P 1
485
#endif
486

487
488
// Determines whether to support Combine(). This only makes sense when
// value-parameterized tests are enabled.
zhanyong.wan's avatar
zhanyong.wan committed
489
490
491
#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
#define GTEST_HAS_COMBINE 1
#endif  // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE
492

493
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
zhanyong.wan's avatar
zhanyong.wan committed
494
495
#define GTEST_WIDE_STRING_USES_UTF16_ \
    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN)
496

shiqian's avatar
shiqian committed
497
498
499
500
501
502
503
504
505
506
507
// 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
508
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
shiqian's avatar
shiqian committed
509
#else
shiqian's avatar
shiqian committed
510
#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0:  // NOLINT
shiqian's avatar
shiqian committed
511
512
#endif

513
// Use this annotation at the end of a struct/class definition to
shiqian's avatar
shiqian committed
514
515
516
517
518
519
// 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
520
//   } GTEST_ATTRIBUTE_UNUSED_;
521
522
523
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
524
#if defined(__GNUC__) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
525
#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
526
#else
shiqian's avatar
shiqian committed
527
#define GTEST_ATTRIBUTE_UNUSED_
528
#endif
shiqian's avatar
shiqian committed
529

530
531
532
533
534
535
// 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
536
// This should be used in the private: declarations for a class.
shiqian's avatar
shiqian committed
537
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
538
539
  type(type const &);\
  GTEST_DISALLOW_ASSIGN_(type)
shiqian's avatar
shiqian committed
540
541
542
543
544

// 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
545
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
546
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
shiqian's avatar
shiqian committed
547
#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
shiqian's avatar
shiqian committed
548
#else
shiqian's avatar
shiqian committed
549
#define GTEST_MUST_USE_RESULT_
shiqian's avatar
shiqian committed
550
#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
shiqian's avatar
shiqian committed
551

552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
// 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

568
569
570
571
572
573
574
575
576
577
578
579
580
581
#ifdef _MSC_VER

#if GTEST_LINKED_AS_SHARED_LIBRARY
#define GTEST_API_ __declspec(dllimport)
#elif GTEST_CREATE_SHARED_LIBRARY
#define GTEST_API_ __declspec(dllexport)
#endif

#endif  // _MSC_VER

#ifndef GTEST_API_
#define GTEST_API_
#endif

shiqian's avatar
shiqian committed
582
583
584
585
586
587
588
589
590
591
namespace testing {

class Message;

namespace internal {

class String;

typedef ::std::stringstream StrStream;

592
593
// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
594
GTEST_API_ bool IsTrue(bool condition);
595

shiqian's avatar
shiqian committed
596
597
598
599
600
601
602
// 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:
603
604
  typedef T element_type;

shiqian's avatar
shiqian committed
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
  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_) {
620
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
shiqian's avatar
shiqian committed
621
622
623
624
625
626
627
628
        delete ptr_;
      }
      ptr_ = p;
    }
  }
 private:
  T* ptr_;

shiqian's avatar
shiqian committed
629
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
630
631
};

632
// Defines RE.
shiqian's avatar
shiqian committed
633
634
635

// A simple C++ wrapper for <regex.h>.  It uses the POSIX Enxtended
// Regular Expression syntax.
636
class GTEST_API_ RE {
shiqian's avatar
shiqian committed
637
638
639
640
641
642
643
644
645
646
647
648
649
650
 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_; }

651
652
653
654
655
656
657
658
659
660
  // 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
661
662
663
664
665
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

#if GTEST_HAS_GLOBAL_STRING
666
667
668
  static bool FullMatch(const ::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
669
670
671
672
673
  static bool PartialMatch(const ::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }
#endif  // GTEST_HAS_GLOBAL_STRING

674
  static bool FullMatch(const char* str, const RE& re);
shiqian's avatar
shiqian committed
675
676
677
678
679
680
681
682
683
684
  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_;
685
686
  bool is_valid_;
#if GTEST_USES_POSIX_RE
687
688
  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().
689
690
691
#else  // GTEST_USES_SIMPLE_RE
  const char* full_pattern_;  // For FullMatch();
#endif
shiqian's avatar
shiqian committed
692

693
694
  GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
};
shiqian's avatar
shiqian committed
695
696

// Defines logging utilities:
697
698
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
shiqian's avatar
shiqian committed
699
700
701
702
703
704
705
706
707
708
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

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

709
710
711
// 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.
712
class GTEST_API_ GTestLog {
713
714
715
716
717
718
719
720
721
722
723
724
725
 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
726

727
728
729
#define GTEST_LOG_(severity) \
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()
shiqian's avatar
shiqian committed
730
731
732
733

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

734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
// 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_ \
    if (::testing::internal::IsTrue(condition)) \
      ; \
    else \
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "

755
756
757
758
759
760
761
762
763
764
// An all-mode assert to verify that the given POSIX-style function
// call returns 0 (indicating success).  Known limitation: this
// doesn't expand to a balanced 'if' statement, so enclose the macro
// in {} if you need to use it as the only statement in an 'if'
// branch.
#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
  if (const int gtest_error = (posix_call)) \
    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
                      << gtest_error

765
#if GTEST_HAS_STREAM_REDIRECTION_
766

shiqian's avatar
shiqian committed
767
// Defines the stderr capturer:
768
769
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
shiqian's avatar
shiqian committed
770
771
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
772
773
774
//
void CaptureStdout();
String GetCapturedStdout();
775
void CaptureStderr();
776
String GetCapturedStderr();
777

778
#endif  // GTEST_HAS_STREAM_REDIRECTION_
779
780


zhanyong.wan's avatar
zhanyong.wan committed
781
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
782
783
784
785
786
787
788
789
790
791
792

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

793
794
#if GTEST_HAS_PTHREAD

795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
// Sleeps for (roughly) n milli-seconds.  This function is only for
// testing Google Test's own constructs.  Don't use it in user tests,
// either directly or indirectly.
inline void SleepMilliseconds(int n) {
  const timespec time = {
    0,                  // 0 seconds.
    n * 1000L * 1000L,  // And n ms.
  };
  nanosleep(&time, NULL);
}

// Allows a controller thread to pause execution of newly created
// threads until notified.  Instances of this class must be created
// and destroyed in the controller thread.
//
// This class is only for testing Google Test's own constructs. Do not
// use it in user tests, either directly or indirectly.
class Notification {
 public:
  Notification() : notified_(false) {}

  // Notifies all threads created with this notification to start. Must
  // be called from the controller thread.
  void Notify() { notified_ = true; }

  // Blocks until the controller thread notifies. Must be called from a test
  // thread.
  void WaitForNotification() {
    while(!notified_) {
      SleepMilliseconds(10);
    }
  }

 private:
  volatile bool notified_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
};

// Helper class for testing Google Test's multi-threading constructs.
zhanyong.wan's avatar
zhanyong.wan committed
835
// To use it, write:
836
837
838
839
840
841
842
843
844
845
846
//
//   void ThreadFunc(int param) { /* Do things with param */ }
//   Notification thread_can_start;
//   ...
//   // The thread_can_start parameter is optional; you can supply NULL.
//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
//   thread_can_start.Notify();
//
// These classes are only for testing Google Test's own constructs. Do
// not use them in user tests, either directly or indirectly.
template <typename T>
zhanyong.wan's avatar
zhanyong.wan committed
847
class ThreadWithParam {
848
849
850
 public:
  typedef void (*UserThreadFunc)(T);

zhanyong.wan's avatar
zhanyong.wan committed
851
  ThreadWithParam(
852
853
854
855
      UserThreadFunc func, T param, Notification* thread_can_start)
      : func_(func),
        param_(param),
        thread_can_start_(thread_can_start),
zhanyong.wan's avatar
zhanyong.wan committed
856
857
858
859
860
861
862
        finished_(false) {
    // The thread can be created only after all fields except thread_
    // have been initialized.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_create(&thread_, 0, ThreadMainStatic, this));
  }
  ~ThreadWithParam() { Join(); }
863
864
865

  void Join() {
    if (!finished_) {
zhanyong.wan's avatar
zhanyong.wan committed
866
      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
867
868
869
870
      finished_ = true;
    }
  }

zhanyong.wan's avatar
zhanyong.wan committed
871
 private:
872
873
874
875
876
877
  void ThreadMain() {
    if (thread_can_start_ != NULL)
      thread_can_start_->WaitForNotification();
    func_(param_);
  }

zhanyong.wan's avatar
zhanyong.wan committed
878
879
880
881
882
  static void* ThreadMainStatic(void* thread_with_param) {
    static_cast<ThreadWithParam<T>*>(thread_with_param)->ThreadMain();
    return NULL;  // We are not interested in the thread exit code.
  }

883
884
885
886
887
888
  const UserThreadFunc func_;  // User-supplied thread function.
  const T param_;  // User-supplied parameter to the thread function.
  // When non-NULL, used to block execution until the controller thread
  // notifies.
  Notification* const thread_can_start_;
  bool finished_;  // true iff we know that the thread function has finished.
zhanyong.wan's avatar
zhanyong.wan committed
889
890
891
  pthread_t thread_;  // The native thread object.

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
892
893
};

894
895
896
897
898
899
900
// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
// true.
#include <pthread.h>

// MutexBase and Mutex implement mutex on pthreads-based platforms. They
// are used in conjunction with class MutexLock:
//
901
902
903
904
//   Mutex mutex;
//   ...
//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the end
//                            // of the current scope.
905
906
//
// MutexBase implements behavior for both statically and dynamically
907
908
// allocated mutexes.  Do not use MutexBase directly.  Instead, write
// the following to define a static mutex:
909
//
910
//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
911
//
912
// You can forward declare a static mutex like this:
913
//
914
//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
915
//
916
// To create a dynamic mutex, just define an object of type Mutex.
917
918
class MutexBase {
 public:
919
920
921
922
923
924
925
926
927
928
929
930
931
932
  // Acquires this mutex.
  void Lock() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
    owner_ = pthread_self();
  }

  // Releases this mutex.
  void Unlock() {
    // We don't protect writing to owner_ here, as it's the caller's
    // responsibility to ensure that the current thread holds the
    // mutex when this is called.
    owner_ = 0;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }
933
934
935

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
936
937
938
939
  void AssertHeld() const {
    GTEST_CHECK_(owner_ == pthread_self())
        << "The current thread is not holding the mutex @" << this;
  }
940

941
942
943
944
945
  // A static mutex may be used before main() is entered.  It may even
  // be used before the dynamic initialization stage.  Therefore we
  // must be able to initialize a static mutex object at link time.
  // This means MutexBase has to be a POD and its member variables
  // have to be public.
946
 public:
947
948
  pthread_mutex_t mutex_;  // The underlying pthread mutex.
  pthread_t owner_;  // The thread holding the mutex; 0 means no one holds it.
949
950
951
952
953
954
};

// Forward-declares a static mutex.
#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
    extern ::testing::internal::MutexBase mutex

955
// Defines and statically (i.e. at link time) initializes a static mutex.
956
957
958
#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 }

959
960
// The Mutex class can only be used for mutexes created at runtime. It
// shares its API with MutexBase otherwise.
961
962
class Mutex : public MutexBase {
 public:
963
964
965
966
967
968
969
  Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
    owner_ = 0;
  }
  ~Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
  }
970
971
972
973
974

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

975
// We cannot name this class MutexLock as the ctor declaration would
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
// conflict with a macro named MutexLock, which is defined on some
// platforms.  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(MutexBase* mutex)
      : mutex_(mutex) { mutex_->Lock(); }

  ~GTestMutexLock() { mutex_->Unlock(); }

 private:
  MutexBase* const mutex_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
};

typedef GTestMutexLock MutexLock;

// Implements thread-local storage on pthreads-based systems.
//
995
996
//   // Thread 1
//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
997
//
998
999
1000
//   // Thread 2
//   tl.set(150);  // Changes the value for thread 2 only.
//   EXPECT_EQ(150, tl.get());
1001
//
1002
1003
1004
1005
//   // Thread 1
//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
//   tl.set(200);
//   EXPECT_EQ(200, tl.get());
1006
//
1007
1008
1009
1010
1011
1012
// The template type argument T must have a public copy constructor.
// In addition, the default ThreadLocal constructor requires T to have
// a public default constructor.  An object managed by a ThreadLocal
// instance for a thread is guaranteed to exist at least until the
// earliest of the two events: (a) the thread terminates or (b) the
// ThreadLocal object is destroyed.
1013
1014
1015
template <typename T>
class ThreadLocal {
 public:
1016
1017
1018
1019
  ThreadLocal() : key_(CreateKey()),
                  default_() {}
  explicit ThreadLocal(const T& value) : key_(CreateKey()),
                                         default_(value) {}
1020
1021

  ~ThreadLocal() {
1022
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
  }

  T* pointer() { return GetOrCreateValue(); }
  const T* pointer() const { return GetOrCreateValue(); }
  const T& get() const { return *pointer(); }
  void set(const T& value) { *pointer() = value; }

 private:
  static pthread_key_t CreateKey() {
    pthread_key_t key;
1033
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_create(&key, &DeleteData));
1034
1035
1036
1037
    return key;
  }

  T* GetOrCreateValue() const {
1038
1039
1040
1041
1042
1043
1044
    T* const value = static_cast<T*>(pthread_getspecific(key_));
    if (value != NULL)
      return value;

    T* const new_value = new T(default_);
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, new_value));
    return new_value;
1045
1046
1047
1048
1049
1050
  }

  static void DeleteData(void* data) { delete static_cast<T*>(data); }

  // A key pthreads uses for looking up per-thread values.
  const pthread_key_t key_;
1051
  const T default_;  // The default value for each thread.
1052
1053
1054
1055
1056
1057
1058
1059

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

#define GTEST_IS_THREADSAFE 1

#else  // GTEST_HAS_PTHREAD

shiqian's avatar
shiqian committed
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
// 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() {}
  void AssertHeld() const {}
};

1071
1072
1073
1074
1075
#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
  extern ::testing::internal::Mutex mutex

#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex

shiqian's avatar
shiqian committed
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex*) {}  // NOLINT
};

typedef GTestMutexLock MutexLock;

template <typename T>
class ThreadLocal {
 public:
shiqian's avatar
shiqian committed
1086
1087
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
1088
1089
1090
1091
1092
1093
1094
1095
  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_;
};

shiqian's avatar
shiqian committed
1096
1097
1098
1099
// The above synchronization primitives have dummy implementations.
// Therefore Google Test is not thread-safe.
#define GTEST_IS_THREADSAFE 0

1100
1101
1102
1103
1104
1105
#endif  // GTEST_HAS_PTHREAD

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount();

1106
// Passing non-POD classes through ellipsis (...) crashes the ARM
1107
1108
1109
1110
1111
1112
1113
1114
// 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
1115

1116
1117
1118
1119
// 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.
1120
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
1121
#define GTEST_NEEDS_IS_POINTER_ 1
1122
#endif
shiqian's avatar
shiqian committed
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139

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

1140
1141
#if GTEST_OS_WINDOWS
#define GTEST_PATH_SEP_ "\\"
1142
#define GTEST_HAS_ALT_PATH_SEP_ 1
1143
1144
// The biggest signed integer type the compiler supports.
typedef __int64 BiggestInt;
1145
1146
#else
#define GTEST_PATH_SEP_ "/"
1147
#define GTEST_HAS_ALT_PATH_SEP_ 0
1148
typedef long long BiggestInt;  // NOLINT
1149
1150
#endif  // GTEST_OS_WINDOWS

1151
1152
// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
1153
1154
1155
1156
// 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.

1157
1158
1159
1160
namespace posix {

// Functions with a different name on Windows.

zhanyong.wan's avatar
zhanyong.wan committed
1161
#if GTEST_OS_WINDOWS
1162

1163
typedef struct _stat StatStruct;
1164

1165
1166
1167
1168
1169
1170
#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); }
1171
#else  // !__BORLANDC__
1172
#if GTEST_OS_WINDOWS_MOBILE
1173
inline int IsATTY(int /* fd */) { return 0; }
1174
#else
1175
inline int IsATTY(int fd) { return _isatty(fd); }
1176
#endif  // GTEST_OS_WINDOWS_MOBILE
1177
1178
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
1179
}
1180
inline char* StrDup(const char* src) { return _strdup(src); }
1181
1182
#endif  // __BORLANDC__

1183
#if GTEST_OS_WINDOWS_MOBILE
1184
1185
1186
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.
1187
#else
1188
1189
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
1190
1191
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
1192
1193
  return (_S_IFDIR & st.st_mode) != 0;
}
1194
#endif  // GTEST_OS_WINDOWS_MOBILE
1195

shiqian's avatar
shiqian committed
1196
#else
1197

1198
typedef struct stat StatStruct;
1199

1200
1201
1202
1203
1204
1205
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);
}
1206
inline char* StrDup(const char* src) { return strdup(src); }
1207
1208
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
1209

shiqian's avatar
shiqian committed
1210
1211
#endif  // GTEST_OS_WINDOWS

1212
1213
1214
1215
1216
1217
1218
1219
// Functions deprecated by MSVC 8.0.

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

1220
1221
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
  return strncpy(dest, src, n);
1222
}
1223
1224
1225
1226
1227

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

1228
#if !GTEST_OS_WINDOWS_MOBILE
1229
inline int ChDir(const char* dir) { return chdir(dir); }
1230
#endif
1231
1232
inline FILE* FOpen(const char* path, const char* mode) {
  return fopen(path, mode);
1233
}
1234
#if !GTEST_OS_WINDOWS_MOBILE
1235
1236
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
1237
}
1238
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
1239
#endif
1240
inline int FClose(FILE* fp) { return fclose(fp); }
1241
#if !GTEST_OS_WINDOWS_MOBILE
1242
1243
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
1244
}
1245
1246
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
1247
}
1248
1249
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
1250
#endif
1251
inline const char* GetEnv(const char* name) {
1252
1253
#if GTEST_OS_WINDOWS_MOBILE
  // We are on Windows CE, which has no environment variables.
1254
  return NULL;
1255
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
1256
1257
1258
1259
  // 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;
1260
#else
1261
  return getenv(name);
1262
1263
1264
1265
1266
1267
1268
#endif
}

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

1269
#if GTEST_OS_WINDOWS_MOBILE
1270
1271
1272
// 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.
1273
void Abort();
1274
#else
1275
inline void Abort() { abort(); }
1276
#endif  // GTEST_OS_WINDOWS_MOBILE
1277
1278
1279

}  // namespace posix

shiqian's avatar
shiqian committed
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
// 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
1332
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
  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.

// Macro for referencing flags.
#define GTEST_FLAG(name) FLAGS_gtest_##name

// Macros for declaring flags.
1354
#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1355
#define GTEST_DECLARE_int32_(name) \
1356
    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1357
#define GTEST_DECLARE_string_(name) \
1358
    GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1359
1360

// Macros for defining flags.
shiqian's avatar
shiqian committed
1361
#define GTEST_DEFINE_bool_(name, default_val, doc) \
1362
    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1363
#define GTEST_DEFINE_int32_(name, default_val, doc) \
1364
    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1365
#define GTEST_DEFINE_string_(name, default_val, doc) \
1366
    GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385

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