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

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

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

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

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

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

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

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

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

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

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

226
227
#define GTEST_USES_POSIX_RE 1

228
229
#elif GTEST_OS_WINDOWS

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

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

239
240
#else

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

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

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

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

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

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

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

shiqian's avatar
shiqian committed
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
// 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

347
// Determines whether Google Test can use the pthreads library.
shiqian's avatar
shiqian committed
348
#ifndef GTEST_HAS_PTHREAD
349
350
351
352
353
354
// 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
355
356
#endif  // GTEST_HAS_PTHREAD

357
358
359
// 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).
360
#ifndef GTEST_HAS_TR1_TUPLE
361
362
363
364
365
366
367
// 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
368
369
// The user didn't tell us, so we need to figure it out.

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

#endif  // GTEST_USE_OWN_TR1_TUPLE
385

386
387
388
389
// 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
390

391
392
393
#if GTEST_USE_OWN_TR1_TUPLE
#include <gtest/internal/gtest-tuple.h>
#elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409

// 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)
410
411
// 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>.
412
413
414
415
416
417
418
419
420
421
422
423

#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
424
#include <tr1/tuple>  // NOLINT
425
426
#endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

427
#else
428
// If the compiler is not GCC 4.0+, we assume the user is using a
429
// spec-conforming TR1 implementation.
430
#include <tuple>  // NOLINT
431
#endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
432

433
434
#endif  // GTEST_HAS_TR1_TUPLE

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

#endif  // GTEST_HAS_CLONE

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

466
467
468
// 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
469
#define GTEST_HAS_PARAM_TEST 1
470

471
472
// Determines whether to support type-driven tests.

473
474
475
// 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)
476
477
#define GTEST_HAS_TYPED_TEST 1
#define GTEST_HAS_TYPED_TEST_P 1
478
#endif
479

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

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

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

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

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

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

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

class Message;

namespace internal {

class String;

typedef ::std::stringstream StrStream;

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

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

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

shiqian's avatar
shiqian committed
608
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
609
610
};

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

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

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

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

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

672
673
  GTEST_DISALLOW_COPY_AND_ASSIGN_(RE);
};
shiqian's avatar
shiqian committed
674
675

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

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

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

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

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

713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
// 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. "

734
735
736
737
738
739
740
741
742
743
// 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

744
#if GTEST_HAS_STREAM_REDIRECTION_
745

shiqian's avatar
shiqian committed
746
// Defines the stderr capturer:
747
748
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
shiqian's avatar
shiqian committed
749
750
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
751
752
753
//
void CaptureStdout();
String GetCapturedStdout();
754
void CaptureStderr();
755
String GetCapturedStderr();
756

757
#endif  // GTEST_HAS_STREAM_REDIRECTION_
758
759


zhanyong.wan's avatar
zhanyong.wan committed
760
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
761
762
763
764
765
766
767
768
769
770
771

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

772
773
#if GTEST_HAS_PTHREAD

774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
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
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
// 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.
// To use it, derive a class template ThreadWithParam<T> from
// ThreadWithParamBase<T> and implement thread creation and startup in
// the constructor and joining the thread in JoinUnderlyingThread().
// Then you can write:
//
//   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>
class ThreadWithParamBase {
 public:
  typedef void (*UserThreadFunc)(T);

  ThreadWithParamBase(
      UserThreadFunc func, T param, Notification* thread_can_start)
      : func_(func),
        param_(param),
        thread_can_start_(thread_can_start),
        finished_(false) {}
  virtual ~ThreadWithParamBase() {}

  void Join() {
    if (!finished_) {
      JoinUnderlyingThread();
      finished_ = true;
    }
  }

  virtual void JoinUnderlyingThread() = 0;

  void ThreadMain() {
    if (thread_can_start_ != NULL)
      thread_can_start_->WaitForNotification();
    func_(param_);
  }

 protected:
  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.
};

865
866
867
868
869
870
871
// 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:
//
872
873
874
875
//   Mutex mutex;
//   ...
//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the end
//                            // of the current scope.
876
877
//
// MutexBase implements behavior for both statically and dynamically
878
879
// allocated mutexes.  Do not use MutexBase directly.  Instead, write
// the following to define a static mutex:
880
//
881
//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
882
//
883
// You can forward declare a static mutex like this:
884
//
885
//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
886
//
887
// To create a dynamic mutex, just define an object of type Mutex.
888
889
class MutexBase {
 public:
890
891
892
893
894
895
896
897
898
899
900
901
902
903
  // 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_));
  }
904
905
906

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
907
908
909
910
  void AssertHeld() const {
    GTEST_CHECK_(owner_ == pthread_self())
        << "The current thread is not holding the mutex @" << this;
  }
911

912
913
914
915
916
  // 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.
917
 public:
918
919
  pthread_mutex_t mutex_;  // The underlying pthread mutex.
  pthread_t owner_;  // The thread holding the mutex; 0 means no one holds it.
920
921
922
923
924
925
};

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

926
// Defines and statically (i.e. at link time) initializes a static mutex.
927
928
929
#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
    ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 }

930
931
// The Mutex class can only be used for mutexes created at runtime. It
// shares its API with MutexBase otherwise.
932
933
class Mutex : public MutexBase {
 public:
934
935
936
937
938
939
940
  Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
    owner_ = 0;
  }
  ~Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
  }
941
942
943
944
945

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

946
// We cannot name this class MutexLock as the ctor declaration would
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
// 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.
//
966
967
//   // Thread 1
//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
968
//
969
970
971
//   // Thread 2
//   tl.set(150);  // Changes the value for thread 2 only.
//   EXPECT_EQ(150, tl.get());
972
//
973
974
975
976
//   // Thread 1
//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
//   tl.set(200);
//   EXPECT_EQ(200, tl.get());
977
//
978
979
980
981
982
983
// 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.
984
985
986
template <typename T>
class ThreadLocal {
 public:
987
988
989
990
  ThreadLocal() : key_(CreateKey()),
                  default_() {}
  explicit ThreadLocal(const T& value) : key_(CreateKey()),
                                         default_(value) {}
991
992

  ~ThreadLocal() {
993
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
994
995
996
997
998
999
1000
1001
1002
1003
  }

  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;
1004
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_create(&key, &DeleteData));
1005
1006
1007
1008
    return key;
  }

  T* GetOrCreateValue() const {
1009
1010
1011
1012
1013
1014
1015
    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;
1016
1017
1018
1019
1020
1021
  }

  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_;
1022
  const T default_;  // The default value for each thread.
1023
1024
1025
1026

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

1027
// Helper class for testing Google Test's multi-threading constructs.
1028
template <typename T>
1029
class ThreadWithParam : public ThreadWithParamBase<T> {
1030
 public:
1031
1032
  ThreadWithParam(void (*func)(T), T param, Notification* thread_can_start)
      : ThreadWithParamBase<T>(func, param, thread_can_start) {
1033
1034
1035
1036
    // The thread can be created only after all fields except thread_
    // have been initialized.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_create(&thread_, 0, ThreadMainStatic, this));
1037
  }
1038
  virtual ~ThreadWithParam() { this->Join(); }
1039

1040
1041
  virtual void JoinUnderlyingThread() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
1042
1043
1044
  }

 private:
1045
1046
1047
  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.
1048
1049
  }

1050
  pthread_t thread_;  // The native thread object.
1051
1052

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1053
1054
1055
1056
1057
1058
};

#define GTEST_IS_THREADSAFE 1

#else  // GTEST_HAS_PTHREAD

shiqian's avatar
shiqian committed
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
// 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 {}
};

1070
1071
1072
1073
1074
#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
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex*) {}  // NOLINT
};

typedef GTestMutexLock MutexLock;

template <typename T>
class ThreadLocal {
 public:
shiqian's avatar
shiqian committed
1085
1086
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
1087
1088
1089
1090
1091
1092
1093
1094
  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
1095
1096
1097
1098
// The above synchronization primitives have dummy implementations.
// Therefore Google Test is not thread-safe.
#define GTEST_IS_THREADSAFE 0

1099
1100
1101
1102
1103
1104
#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();

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

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

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

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

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

1156
1157
1158
1159
namespace posix {

// Functions with a different name on Windows.

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

1162
typedef struct _stat StatStruct;
1163

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

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

shiqian's avatar
shiqian committed
1195
#else
1196

1197
typedef struct stat StatStruct;
1198

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

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

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

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

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

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

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

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

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

}  // namespace posix

shiqian's avatar
shiqian committed
1279
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
// 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
1331
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
  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.
shiqian's avatar
shiqian committed
1353
1354
#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
#define GTEST_DECLARE_int32_(name) \
shiqian's avatar
shiqian committed
1355
    extern ::testing::internal::Int32 GTEST_FLAG(name)
shiqian's avatar
shiqian committed
1356
#define GTEST_DECLARE_string_(name) \
shiqian's avatar
shiqian committed
1357
1358
1359
    extern ::testing::internal::String GTEST_FLAG(name)

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