gtest-port.h 92.7 KB
Newer Older
shiqian's avatar
shiqian committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 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
33
34
35
36
37
// platforms.  All macros ending with _ and symbols defined in an
// internal namespace are subject to change without notice.  Code
// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
// end with _ are part of Google Test's public API and can be used by
// code outside Google Test.
38
39
40
41
//
// This file is fundamental to Google Test.  All other Google Test source
// files are expected to #include this.  Therefore, it cannot #include
// any other Google Test header.
shiqian's avatar
shiqian committed
42
43
44
45

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// Environment-describing macros
// -----------------------------
//
// Google Test can be used in many different environments.  Macros in
// this section tell Google Test what kind of environment it is being
// used in, such that Google Test can provide environment-specific
// features and implementations.
//
// Google Test tries to automatically detect the properties of its
// environment, so users usually don't need to worry about these
// macros.  However, the automatic detection is not perfect.
// Sometimes it's necessary for a user to define some of the following
// macros in the build script to override Google Test's decisions.
//
// If the user doesn't define a macro in the list, Google Test will
// provide a default definition.  After this header is #included, all
// macros in this list will be defined to either 1 or 0.
//
// Notes to maintainers:
//   - Each macro here is a user-tweakable knob; do not grow the list
//     lightly.
//   - Use #if to key off these macros.  Don't use #ifdef or "#if
//     defined(...)", which will not work as these macros are ALWAYS
//     defined.
shiqian's avatar
shiqian committed
70
//
71
72
//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
//                              is/isn't available.
73
74
//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
//                              are enabled.
shiqian's avatar
shiqian committed
75
//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
Gennadiy Civil's avatar
merges  
Gennadiy Civil committed
76
77
78
//                              is/isn't available
//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::wstring
//                              is/isn't available
79
80
//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
//                              expressions are/aren't available.
shiqian's avatar
shiqian committed
81
82
//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
//                              is/isn't available.
83
84
85
86
87
//   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).
88
//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
89
//                              is/isn't available.
90
91
92
//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
//                              compiler supports Microsoft's "Structured
//                              Exception Handling".
93
94
95
96
//   GTEST_HAS_STREAM_REDIRECTION
//                            - Define it to 1/0 to indicate whether the
//                              platform supports I/O stream redirection using
//                              dup() and dup2().
97
98
99
100
//   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.
101
102
//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
//                              is building in C++11/C++98 mode.
103
104
105
106
107
108
109
//   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.
110
111
112
113
114
115
//   GTEST_DEFAULT_DEATH_TEST_STYLE
//                            - The default value of --gtest_death_test_style.
//                              The legacy default has been "fast" in the open
//                              source version since 2008. The recommended value
//                              is "threadsafe", and can be set in
//                              custom/gtest-port.h.
shiqian's avatar
shiqian committed
116

117
118
119
120
121
122
123
124
// Platform-indicating macros
// --------------------------
//
// Macros indicating the platform on which Google Test is being used
// (a macro is defined to 1 if compiled on the given platform;
// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
// defines these macros automatically.  Code outside Google Test MUST
// NOT define them.
shiqian's avatar
shiqian committed
125
//
126
//   GTEST_OS_AIX      - IBM AIX
zhanyong.wan's avatar
zhanyong.wan committed
127
//   GTEST_OS_CYGWIN   - Cygwin
kosak's avatar
kosak committed
128
//   GTEST_OS_FREEBSD  - FreeBSD
129
//   GTEST_OS_FUCHSIA  - Fuchsia
130
//   GTEST_OS_HPUX     - HP-UX
zhanyong.wan's avatar
zhanyong.wan committed
131
//   GTEST_OS_LINUX    - Linux
132
//     GTEST_OS_LINUX_ANDROID - Google Android
zhanyong.wan's avatar
zhanyong.wan committed
133
//   GTEST_OS_MAC      - Mac OS X
jgm's avatar
jgm committed
134
//     GTEST_OS_IOS    - iOS
135
//   GTEST_OS_NACL     - Google Native Client (NaCl)
Kamil Rytarowski's avatar
Kamil Rytarowski committed
136
//   GTEST_OS_NETBSD   - NetBSD
137
//   GTEST_OS_OPENBSD  - OpenBSD
138
//   GTEST_OS_QNX      - QNX
zhanyong.wan's avatar
zhanyong.wan committed
139
140
//   GTEST_OS_SOLARIS  - Sun Solaris
//   GTEST_OS_SYMBIAN  - Symbian
141
142
143
//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
//     GTEST_OS_WINDOWS_MINGW    - MinGW
144
//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
billydonahue's avatar
billydonahue committed
145
146
//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
zhanyong.wan's avatar
zhanyong.wan committed
147
//   GTEST_OS_ZOS      - z/OS
148
//
149
150
151
152
153
154
155
// 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!).
//
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
// It is possible that none of the GTEST_OS_* macros are defined.

// Feature-indicating macros
// -------------------------
//
// Macros indicating which Google Test features are available (a macro
// is defined to 1 if the corresponding feature is supported;
// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
// defines these macros automatically.  Code outside Google Test MUST
// NOT define them.
//
// These macros are public so that portable tests can be written.
// Such tests typically surround code using a feature with an #if
// which controls that code.  For example:
//
// #if GTEST_HAS_DEATH_TEST
//   EXPECT_DEATH(DoSomethingDeadly());
// #endif
shiqian's avatar
shiqian committed
174
//
zhanyong.wan's avatar
zhanyong.wan committed
175
176
177
178
179
//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
//                            tests)
//   GTEST_HAS_DEATH_TEST   - death tests
//   GTEST_HAS_TYPED_TEST   - typed tests
//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
180
//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
181
182
183
//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
//                            GTEST_HAS_POSIX_RE (see above) which users can
//                            define themselves.
zhanyong.wan's avatar
zhanyong.wan committed
184
//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
Gennadiy Civil's avatar
 
Gennadiy Civil committed
185
//                            the above RE\b(s) are mutually exclusive.
186
//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
187
188
189
190
191
192
193
194
195
196
197
198

// Misc public macros
// ------------------
//
//   GTEST_FLAG(flag_name)  - references the variable corresponding to
//                            the given Google Test flag.

// Internal utilities
// ------------------
//
// The following macros and utilities are for Google Test's INTERNAL
// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
shiqian's avatar
shiqian committed
199
200
//
// Macros for basic C++ coding:
shiqian's avatar
shiqian committed
201
//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
202
203
//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
//                              variable don't have to be used.
204
//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
shiqian's avatar
shiqian committed
205
206
//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
207
208
209
210
//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
//                                        suppressed (constant conditional).
//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
//                                        is suppressed.
shiqian's avatar
shiqian committed
211
//
212
213
// C++11 feature wrappers:
//
Gennadiy Civil's avatar
 
Gennadiy Civil committed
214
//   testing::internal::forward - portability wrapper for std::forward.
215
//   testing::internal::move  - portability wrapper for std::move.
216
//
shiqian's avatar
shiqian committed
217
218
// Synchronization:
//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
219
//                            - synchronization primitives.
shiqian's avatar
shiqian committed
220
221
//
// Template meta programming:
222
//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
223
224
//   IteratorTraits - partial implementation of std::iterator_traits, which
//                    is not available in libCstd when compiled with Sun C++.
shiqian's avatar
shiqian committed
225
226
227
228
229
230
//
// Smart pointers:
//   scoped_ptr     - as in TR2.
//
// Regular expressions:
//   RE             - a simple regular expression class using the POSIX
231
232
233
//                    Extended Regular Expression syntax on UNIX-like platforms
//                    or a reduced regular exception syntax on other
//                    platforms, including Windows.
shiqian's avatar
shiqian committed
234
// Logging:
shiqian's avatar
shiqian committed
235
//   GTEST_LOG_()   - logs messages at the specified severity level.
shiqian's avatar
shiqian committed
236
237
238
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.
//
239
240
241
242
// Stdout and stderr capturing:
//   CaptureStdout()     - starts capturing stdout.
//   GetCapturedStdout() - stops capturing stdout and returns the captured
//                         string.
shiqian's avatar
shiqian committed
243
244
245
246
247
248
249
250
251
252
253
254
255
//   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_DECLARE_*()  - declares a flag.
//   GTEST_DEFINE_*()   - defines a flag.
256
//   GetInjectableArgvs() - returns the command line as a vector of strings.
shiqian's avatar
shiqian committed
257
258
259
260
261
262
263
//
// 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.

264
265
#include <ctype.h>   // for isspace, etc
#include <stddef.h>  // for ptrdiff_t
shiqian's avatar
shiqian committed
266
267
#include <stdlib.h>
#include <stdio.h>
268
#include <string.h>
269
#ifndef _WIN32_WCE
270
271
# include <sys/types.h>
# include <sys/stat.h>
272
#endif  // !_WIN32_WCE
273

jgm's avatar
jgm committed
274
275
276
277
278
#if defined __APPLE__
# include <AvailabilityMacros.h>
# include <TargetConditionals.h>
#endif

Gennadiy Civil's avatar
merges  
Gennadiy Civil committed
279
280
281
// Brings in the definition of HAS_GLOBAL_STRING.  This must be done
// BEFORE we test HAS_GLOBAL_STRING.
#include <string>  // NOLINT
billydonahue's avatar
billydonahue committed
282
#include <algorithm>  // NOLINT
283
#include <iostream>  // NOLINT
284
#include <sstream>  // NOLINT
285
#include <utility>
286
#include <vector>  // NOLINT
shiqian's avatar
shiqian committed
287

288
289
290
291
292
293
294
295
296
#include "gtest/internal/gtest-port-arch.h"
#include "gtest/internal/custom/gtest-port.h"

#if !defined(GTEST_DEV_EMAIL_)
# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
# define GTEST_FLAG_PREFIX_ "gtest_"
# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
# define GTEST_NAME_ "Google Test"
297
# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
298
#endif  // !defined(GTEST_DEV_EMAIL_)
shiqian's avatar
shiqian committed
299

300
301
302
303
#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)

shiqian's avatar
shiqian committed
304
305
306
// Determines the version of gcc that is used to compile this.
#ifdef __GNUC__
// 40302 means version 4.3.2.
307
# define GTEST_GCC_VER_ \
shiqian's avatar
shiqian committed
308
309
310
    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
#endif  // __GNUC__

billydonahue's avatar
billydonahue committed
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
// Macros for disabling Microsoft Visual C++ warnings.
//
//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
//   /* code that triggers warnings C4800 and C4385 */
//   GTEST_DISABLE_MSC_WARNINGS_POP_()
#if _MSC_VER >= 1500
# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
    __pragma(warning(push))                        \
    __pragma(warning(disable: warnings))
# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
    __pragma(warning(pop))
#else
// Older versions of MSVC don't have __pragma.
# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
# define GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif

328
329
330
331
332
#ifndef GTEST_LANG_CXX11
// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
// value for __cplusplus, and recent versions of clang, gcc, and
// probably other compilers set that too in C++11 mode.
333
# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L || _MSC_VER >= 1900
334
335
336
337
338
339
340
// Compiling in at least C++11 mode.
#  define GTEST_LANG_CXX11 1
# else
#  define GTEST_LANG_CXX11 0
# endif
#endif

341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
// Distinct from C++11 language support, some environments don't provide
// proper C++11 library support. Notably, it's possible to build in
// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
// with no C++11 support.
//
// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
// this date, so check for those versions by their date stamps.
// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
#if GTEST_LANG_CXX11 && \
    (!defined(__GLIBCXX__) || ( \
        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
        /* Blacklist of patch releases of older branches: */ \
        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
# define GTEST_STDLIB_CXX11 1
#endif

// Only use C++11 library features if the library provides them.
#if GTEST_STDLIB_CXX11
# define GTEST_HAS_STD_BEGIN_AND_END_ 1
# define GTEST_HAS_STD_FORWARD_LIST_ 1
365
366
# if !defined(_MSC_VER) || (_MSC_FULL_VER >= 190023824)
// works only with VS2015U2 and better
367
368
#   define GTEST_HAS_STD_FUNCTION_ 1
# endif
369
# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
370
# define GTEST_HAS_STD_MOVE_ 1
371
# define GTEST_HAS_STD_UNIQUE_PTR_ 1
372
# define GTEST_HAS_STD_SHARED_PTR_ 1
Gennadiy Civil's avatar
Gennadiy Civil committed
373
374
# define GTEST_HAS_UNORDERED_MAP_ 1
# define GTEST_HAS_UNORDERED_SET_ 1
375
376
#endif

377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
// C++11 specifies that <tuple> provides std::tuple.
// Some platforms still might not have it, however.
#if GTEST_LANG_CXX11
# define GTEST_HAS_STD_TUPLE_ 1
# if defined(__clang__)
// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
#  if defined(__has_include) && !__has_include(<tuple>)
#   undef GTEST_HAS_STD_TUPLE_
#  endif
# elif defined(_MSC_VER)
// Inspired by boost/config/stdlib/dinkumware.hpp
#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
#   undef GTEST_HAS_STD_TUPLE_
#  endif
# elif defined(__GLIBCXX__)
// Inspired by boost/config/stdlib/libstdcpp3.hpp,
// http://gcc.gnu.org/gcc-4.2/changes.html and
// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
#   undef GTEST_HAS_STD_TUPLE_
#  endif
# endif
#endif

401
402
403
// Brings in definitions for functions used in the testing::internal::posix
// namespace (read, write, close, chdir, isatty, stat). We do not currently
// use them on Windows Mobile.
404
405
406
407
408
409
#if GTEST_OS_WINDOWS
# if !GTEST_OS_WINDOWS_MOBILE
#  include <direct.h>
#  include <io.h>
# endif
// In order to avoid having to include <windows.h>, use forward declaration
Arkadiy Shapkin's avatar
Arkadiy Shapkin committed
410
#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
411
412
413
414
415
// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
// separate (equivalent) structs, instead of using typedef
typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#else
// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
416
417
// This assumption is verified by
// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
418
419
typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#endif
420
#else
421
422
423
// This assumes that non-Windows OSes provide unistd.h. For OSes where this
// is not the case, we need to include headers that provide the functions
// mentioned above.
424
# include <unistd.h>
425
# include <strings.h>
426
#endif  // GTEST_OS_WINDOWS
427

428
429
430
431
432
#if GTEST_OS_LINUX_ANDROID
// Used to define __ANDROID_API__ matching the target NDK API level.
#  include <android/api-level.h>  // NOLINT
#endif

433
434
// Defines this to true iff Google Test can use POSIX regular expressions.
#ifndef GTEST_HAS_POSIX_RE
435
436
437
438
439
440
# if GTEST_OS_LINUX_ANDROID
// On Android, <regex.h> is only available starting with Gingerbread.
#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
# else
#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
# endif
441
442
#endif

443
444
445
446
#if GTEST_USES_PCRE
// The appropriate headers have already been included.

#elif GTEST_HAS_POSIX_RE
447
448
449
450
451

// 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>.
452
# include <regex.h>  // NOLINT
453

454
# define GTEST_USES_POSIX_RE 1
455

456
457
458
459
#elif GTEST_OS_WINDOWS

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

462
463
#else

464
465
// <regex.h> may not be available on this platform.  Use our own
// simple regex implementation instead.
466
# define GTEST_USES_SIMPLE_RE 1
467

468
#endif  // GTEST_USES_PCRE
469

470
471
472
#ifndef GTEST_HAS_EXCEPTIONS
// The user didn't tell us whether exceptions are enabled, so we need
// to figure it out.
473
474
475
476
477
# if defined(_MSC_VER) && defined(_CPPUNWIND)
// MSVC defines _CPPUNWIND to 1 iff exceptions are enabled.
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__BORLANDC__)
// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
478
// macro to enable exceptions, so we'll do the same.
shiqian's avatar
shiqian committed
479
// Assumes that exceptions are enabled by default.
480
481
482
483
#  ifndef _HAS_EXCEPTIONS
#   define _HAS_EXCEPTIONS 1
#  endif  // _HAS_EXCEPTIONS
#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
484
# elif defined(__clang__)
485
486
487
488
489
490
491
// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
// but iff cleanups are enabled after that. In Obj-C++ files, there can be
// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
// exceptions starting at clang r206352, but which checked for cleanups prior to
// that. To reliably check for C++ exception availability with clang, check for
// __EXCEPTIONS && __has_feature(cxx_exceptions).
kosak's avatar
kosak committed
492
#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
493
# elif defined(__GNUC__) && __EXCEPTIONS
494
// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
495
496
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__SUNPRO_CC)
497
498
499
// 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.
500
501
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__IBMCPP__) && __EXCEPTIONS
502
// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
503
#  define GTEST_HAS_EXCEPTIONS 1
504
505
506
507
# elif defined(__HP_aCC)
// Exception handling is in effect by default in HP aCC compiler. It has to
// be turned of by +noeh compiler option if desired.
#  define GTEST_HAS_EXCEPTIONS 1
508
# else
509
510
// For other compilers, we assume exceptions are disabled to be
// conservative.
511
512
#  define GTEST_HAS_EXCEPTIONS 0
# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
513
#endif  // GTEST_HAS_EXCEPTIONS
shiqian's avatar
shiqian committed
514

515
516
517
#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.
518
# define GTEST_HAS_STD_STRING 1
519
520
#elif !GTEST_HAS_STD_STRING
// The user told us that ::std::string isn't available.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
521
# error "::std::string isn't available."
522
#endif  // !defined(GTEST_HAS_STD_STRING)
shiqian's avatar
shiqian committed
523
524
525
526
527

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

528
# define GTEST_HAS_GLOBAL_STRING 0
shiqian's avatar
shiqian committed
529
530
531
532
533
534
535
536
537

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

538
// Cygwin 1.7 and below doesn't support ::std::wstring.
539
540
541
542
// Solaris' libc++ doesn't support it either.  Android has
// no support for it at least as recent as Froyo (2.2).
# define GTEST_HAS_STD_WSTRING \
    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
shiqian's avatar
shiqian committed
543
544
545
546
547
548

#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.
549
# define GTEST_HAS_GLOBAL_WSTRING \
550
    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
shiqian's avatar
shiqian committed
551
552
#endif  // GTEST_HAS_GLOBAL_WSTRING

shiqian's avatar
shiqian committed
553
554
555
556
557
// 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.

558
# ifdef _MSC_VER
shiqian's avatar
shiqian committed
559

560
561
562
563
564
#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
#   define GTEST_HAS_RTTI 1
#  else
#   define GTEST_HAS_RTTI 0
#  endif
shiqian's avatar
shiqian committed
565
566

// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
567
# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
568

569
#  ifdef __GXX_RTTI
570
571
572
573
574
575
576
577
578
579
// When building against STLport with the Android NDK and with
// -frtti -fno-exceptions, the build fails at link time with undefined
// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
// so disable RTTI when detected.
#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
       !defined(__EXCEPTIONS)
#    define GTEST_HAS_RTTI 0
#   else
#    define GTEST_HAS_RTTI 1
#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
580
581
582
#  else
#   define GTEST_HAS_RTTI 0
#  endif  // __GXX_RTTI
shiqian's avatar
shiqian committed
583

584
585
586
587
588
589
590
// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
// first version with C++ support.
# elif defined(__clang__)

#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)

591
592
// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
// both the typeid and dynamic_cast features are present.
593
# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
594

595
596
597
598
599
#  ifdef __RTTI_ALL__
#   define GTEST_HAS_RTTI 1
#  else
#   define GTEST_HAS_RTTI 0
#  endif
600

601
# else
shiqian's avatar
shiqian committed
602

603
// For all other compilers, we assume RTTI is enabled.
604
#  define GTEST_HAS_RTTI 1
shiqian's avatar
shiqian committed
605

606
# endif  // _MSC_VER
shiqian's avatar
shiqian committed
607
608
609

#endif  // GTEST_HAS_RTTI

610
611
612
// It's this header's responsibility to #include <typeinfo> when RTTI
// is enabled.
#if GTEST_HAS_RTTI
613
# include <typeinfo>
614
615
#endif

616
// Determines whether Google Test can use the pthreads library.
shiqian's avatar
shiqian committed
617
#ifndef GTEST_HAS_PTHREAD
618
619
// The user didn't tell us explicitly, so we make reasonable assumptions about
// which platforms have pthreads support.
620
621
622
//
// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
// to your compiler flags.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
623
624
#define GTEST_HAS_PTHREAD                                             \
  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
625
   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)
shiqian's avatar
shiqian committed
626
627
#endif  // GTEST_HAS_PTHREAD

628
629
630
#if GTEST_HAS_PTHREAD
// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
// true.
631
# include <pthread.h>  // NOLINT
632
633

// For timespec and nanosleep, used below.
634
# include <time.h>  // NOLINT
635
636
#endif

637
638
639
// Determines if hash_map/hash_set are available.
// Only used for testing against those containers.
#if !defined(GTEST_HAS_HASH_MAP_)
640
# if defined(_MSC_VER) && (_MSC_VER < 1900)
641
642
643
644
645
#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
# endif  // _MSC_VER
#endif  // !defined(GTEST_HAS_HASH_MAP_)

646
647
648
// 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).
649
#ifndef GTEST_HAS_TR1_TUPLE
650
651
652
# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
#  define GTEST_HAS_TR1_TUPLE 0
653
# elif defined(_MSC_VER) && (_MSC_VER >= 1910)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
654
655
656
// Prevent `warning C4996: 'std::tr1': warning STL4002:
// The non-Standard std::tr1 namespace and TR1-only machinery
// are deprecated and will be REMOVED.`
657
#  define GTEST_HAS_TR1_TUPLE 0
Gennadiy Civil's avatar
 
Gennadiy Civil committed
658
# elif GTEST_LANG_CXX11 && defined(_LIBCPP_VERSION)
Gennadiy Civil's avatar
Gennadiy Civil committed
659
660
// libc++ doesn't support TR1.
#  define GTEST_HAS_TR1_TUPLE 0
661
# else
662
// The user didn't tell us not to do it, so we assume it's OK.
663
664
#  define GTEST_HAS_TR1_TUPLE 1
# endif
665
666
667
668
669
#endif  // GTEST_HAS_TR1_TUPLE

// Determines whether Google Test's own tr1 tuple implementation
// should be used.
#ifndef GTEST_USE_OWN_TR1_TUPLE
670
671
672
673
// We use our own tuple implementation on Symbian.
# if GTEST_OS_SYMBIAN
#  define GTEST_USE_OWN_TR1_TUPLE 1
# else
674
675
// The user didn't tell us, so we need to figure it out.

676
// We use our own TR1 tuple if we aren't sure the user has an
677
678
679
680
681
682
683
684
685
// implementation of it already.  At this time, libstdc++ 4.0.0+ and
// MSVC 2010 are the only mainstream standard libraries that come
// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
// pretends to be GCC by defining __GNUC__ and friends, but cannot
// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
// tuple in a 323 MB Feature Pack download, which we cannot assume the
// user has.  QNX's QCC compiler is a modified GCC but it doesn't
// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
// and it can be used with some compilers that define __GNUC__.
686
# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
687
688
      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) \
      || (_MSC_VER >= 1600 && _MSC_VER < 1900)
689
690
691
#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
# endif

692
693
694
695
// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
// can build with clang but need to use gcc4.2's libstdc++).
# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
696
697
698
699
#  define GTEST_ENV_HAS_STD_TUPLE_ 1
# endif

# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
700
701
702
703
#  define GTEST_USE_OWN_TR1_TUPLE 0
# else
#  define GTEST_USE_OWN_TR1_TUPLE 1
# endif
704
# endif  // GTEST_OS_SYMBIAN
705
#endif  // GTEST_USE_OWN_TR1_TUPLE
706

707
708
// To avoid conditional compilation we make it gtest-port.h's responsibility
// to #include the header implementing tuple.
billydonahue's avatar
billydonahue committed
709
710
#if GTEST_HAS_STD_TUPLE_
# include <tuple>  // IWYU pragma: export
711
# define GTEST_TUPLE_NAMESPACE_ ::std
billydonahue's avatar
billydonahue committed
712
#endif  // GTEST_HAS_STD_TUPLE_
713

billydonahue's avatar
billydonahue committed
714
715
// We include tr1::tuple even if std::tuple is available to define printers for
// them.
716
#if GTEST_HAS_TR1_TUPLE
717
718
719
# ifndef GTEST_TUPLE_NAMESPACE_
#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
# endif  // GTEST_TUPLE_NAMESPACE_
zhanyong.wan's avatar
zhanyong.wan committed
720

721
# if GTEST_USE_OWN_TR1_TUPLE
billydonahue's avatar
billydonahue committed
722
#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT
723
# elif GTEST_OS_SYMBIAN
zhanyong.wan's avatar
zhanyong.wan committed
724
725
726
727
728
729

// 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.
730
731
732
#  ifdef BOOST_HAS_TR1_TUPLE
#   undef BOOST_HAS_TR1_TUPLE
#  endif  // BOOST_HAS_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
733
734
735

// This prevents <boost/tr1/detail/config.hpp>, which defines
// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
736
#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
billydonahue's avatar
billydonahue committed
737
#  include <tuple>  // IWYU pragma: export  // NOLINT
zhanyong.wan's avatar
zhanyong.wan committed
738

739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
// 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>.

#  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 they choose to.
#  else
#   include <tr1/tuple>  // NOLINT
#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

# else
// If the compiler is not GCC 4.0+, we assume the user is using a
// spec-conforming TR1 implementation.
billydonahue's avatar
billydonahue committed
760
#  include <tuple>  // IWYU pragma: export  // NOLINT
761
# endif  // GTEST_USE_OWN_TR1_TUPLE
zhanyong.wan's avatar
zhanyong.wan committed
762

763
764
#endif  // GTEST_HAS_TR1_TUPLE

765
766
767
768
769
770
771
// 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.

772
# if GTEST_OS_LINUX && !defined(__ia64__)
773
#  if GTEST_OS_LINUX_ANDROID
774
775
776
777
778
779
// On Android, clone() became available at different API levels for each 32-bit
// architecture.
#    if defined(__LP64__) || \
        (defined(__arm__) && __ANDROID_API__ >= 9) || \
        (defined(__mips__) && __ANDROID_API__ >= 12) || \
        (defined(__i386__) && __ANDROID_API__ >= 17)
780
781
782
783
784
785
786
#     define GTEST_HAS_CLONE 1
#    else
#     define GTEST_HAS_CLONE 0
#    endif
#  else
#   define GTEST_HAS_CLONE 1
#  endif
787
788
789
# else
#  define GTEST_HAS_CLONE 0
# endif  // GTEST_OS_LINUX && !defined(__ia64__)
790
791
792

#endif  // GTEST_HAS_CLONE

793
794
// Determines whether to support stream redirection. This is used to test
// output correctness and to implement death tests.
795
796
797
#ifndef GTEST_HAS_STREAM_REDIRECTION
// By default, we assume that stream redirection is supported on all
// platforms except known mobile ones.
billydonahue's avatar
billydonahue committed
798
799
# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
800
801
802
803
#  define GTEST_HAS_STREAM_REDIRECTION 0
# else
#  define GTEST_HAS_STREAM_REDIRECTION 1
# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
804
#endif  // GTEST_HAS_STREAM_REDIRECTION
805

shiqian's avatar
shiqian committed
806
// Determines whether to support death tests.
807
808
809
// 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.
Gennadiy Civil's avatar
merges  
Gennadiy Civil committed
810
811
812
#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||   \
     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                         \
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) ||          \
813
     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
Kamil Rytarowski's avatar
Kamil Rytarowski committed
814
     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NETBSD)
815
# define GTEST_HAS_DEATH_TEST 1
816
#endif
shiqian's avatar
shiqian committed
817

818
819
// Determines whether to support type-driven tests.

820
// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
821
// Sun Pro CC, IBM Visual Age, and HP aCC support.
822
#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
823
    defined(__IBMCPP__) || defined(__HP_aCC)
824
825
# define GTEST_HAS_TYPED_TEST 1
# define GTEST_HAS_TYPED_TEST_P 1
826
#endif
827

Gennadiy Civil's avatar
merges  
Gennadiy Civil committed
828
829
830
831
// Determines whether to support Combine(). This only makes sense when
// value-parameterized tests are enabled.  The implementation doesn't
// work on Sun Studio since it doesn't understand templated conversion
// operators.
832
#if (GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_) && !defined(__SUNPRO_CC)
833
# define GTEST_HAS_COMBINE 1
834
#endif
835

836
// Determines whether the system compiler uses UTF-16 for encoding wide strings.
zhanyong.wan's avatar
zhanyong.wan committed
837
#define GTEST_WIDE_STRING_USES_UTF16_ \
838
    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
839

840
841
// Determines whether test results can be streamed to a socket.
#if GTEST_OS_LINUX
842
# define GTEST_CAN_STREAM_RESULTS_ 1
843
844
#endif

shiqian's avatar
shiqian committed
845
846
847
848
849
850
851
852
853
854
855
// 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
856
# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
shiqian's avatar
shiqian committed
857
#else
858
# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
shiqian's avatar
shiqian committed
859
860
#endif

861
// Use this annotation at the end of a struct/class definition to
shiqian's avatar
shiqian committed
862
863
864
865
866
867
// 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
868
//   } GTEST_ATTRIBUTE_UNUSED_;
869
870
871
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
872
#if defined(__GNUC__) && !defined(COMPILER_ICC)
873
# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
874
875
876
877
878
879
#elif defined(__clang__)
# if __has_attribute(unused)
#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
# endif
#endif
#ifndef GTEST_ATTRIBUTE_UNUSED_
880
# define GTEST_ATTRIBUTE_UNUSED_
881
#endif
shiqian's avatar
shiqian committed
882

Gennadiy Civil's avatar
 
Gennadiy Civil committed
883
884
885
886
887
888
#if GTEST_LANG_CXX11
# define GTEST_CXX11_EQUALS_DELETE_ = delete
#else  // GTEST_LANG_CXX11
# define GTEST_CXX11_EQUALS_DELETE_
#endif  // GTEST_LANG_CXX11

889
// Use this annotation before a function that takes a printf format string.
890
#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
# if defined(__MINGW_PRINTF_FORMAT)
// MinGW has two different printf implementations. Ensure the format macro
// matches the selected implementation. See
// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
                                 first_to_check)))
# else
#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
       __attribute__((__format__(__printf__, string_index, first_to_check)))
# endif
#else
# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
#endif

Gennadiy Civil's avatar
 
Gennadiy Civil committed
906

907
908
// A macro to disallow operator=
// This should be used in the private: declarations for a class.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
909
910
#define GTEST_DISALLOW_ASSIGN_(type) \
  void operator=(type const &) GTEST_CXX11_EQUALS_DELETE_
911
912

// A macro to disallow copy constructor and operator=
shiqian's avatar
shiqian committed
913
// This should be used in the private: declarations for a class.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
914
915
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
  type(type const &) GTEST_CXX11_EQUALS_DELETE_; \
916
  GTEST_DISALLOW_ASSIGN_(type)
shiqian's avatar
shiqian committed
917
918
919
920
921

// 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
922
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
923
#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
924
# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
shiqian's avatar
shiqian committed
925
#else
926
# define GTEST_MUST_USE_RESULT_
shiqian's avatar
shiqian committed
927
#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
shiqian's avatar
shiqian committed
928

929
930
931
932
// MS C++ compiler emits warning when a conditional expression is compile time
// constant. In some contexts this warning is false positive and needs to be
// suppressed. Use the following two macros in such cases:
//
billydonahue's avatar
billydonahue committed
933
// GTEST_INTENTIONAL_CONST_COND_PUSH_()
934
// while (true) {
billydonahue's avatar
billydonahue committed
935
// GTEST_INTENTIONAL_CONST_COND_POP_()
936
// }
billydonahue's avatar
billydonahue committed
937
938
939
940
# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
# define GTEST_INTENTIONAL_CONST_COND_POP_() \
    GTEST_DISABLE_MSC_WARNINGS_POP_()
941

942
943
944
945
946
947
// 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.

948
# if defined(_MSC_VER) || defined(__BORLANDC__)
949
// These two compilers are known to support SEH.
950
951
#  define GTEST_HAS_SEH 1
# else
952
// Assume no SEH.
953
954
#  define GTEST_HAS_SEH 0
# endif
955

956
#define GTEST_IS_THREADSAFE \
957
    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
958
959
     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \
     || GTEST_HAS_PTHREAD)
960

961
962
#endif  // GTEST_HAS_SEH

963
964
965
966
967
// GTEST_API_ qualifies all symbols that must be exported. The definitions below
// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
// gtest/internal/custom/gtest-port.h
#ifndef GTEST_API_

968
#ifdef _MSC_VER
969
970
971
972
973
# if GTEST_LINKED_AS_SHARED_LIBRARY
#  define GTEST_API_ __declspec(dllimport)
# elif GTEST_CREATE_SHARED_LIBRARY
#  define GTEST_API_ __declspec(dllexport)
# endif
974
975
#elif __GNUC__ >= 4 || defined(__clang__)
# define GTEST_API_ __attribute__((visibility ("default")))
976
#endif  // _MSC_VER
977

978
#endif  // GTEST_API_
979

980
#ifndef GTEST_API_
981
# define GTEST_API_
982
#endif  // GTEST_API_
983

984
985
986
987
#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE

988
#ifdef __GNUC__
989
// Ask the compiler to never inline a given function.
990
# define GTEST_NO_INLINE_ __attribute__((noinline))
991
#else
992
993
# define GTEST_NO_INLINE_
#endif
994

995
// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
996
997
998
999
1000
1001
#if !defined(GTEST_HAS_CXXABI_H_)
# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
#  define GTEST_HAS_CXXABI_H_ 1
# else
#  define GTEST_HAS_CXXABI_H_ 0
# endif
1002
1003
#endif

1004
1005
1006
1007
1008
1009
1010
1011
// A function level attribute to disable checking for use of uninitialized
// memory when built with MemorySanitizer.
#if defined(__clang__)
# if __has_feature(memory_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
       __attribute__((no_sanitize_memory))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
1012
# endif  // __has_feature(memory_sanitizer)
1013
1014
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
#endif  // __clang__

// A function level attribute to disable AddressSanitizer instrumentation.
#if defined(__clang__)
# if __has_feature(address_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
       __attribute__((no_sanitize_address))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
# endif  // __has_feature(address_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
#endif  // __clang__
1028

1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
// A function level attribute to disable ThreadSanitizer instrumentation.
#if defined(__clang__)
# if __has_feature(thread_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
       __attribute__((no_sanitize_thread))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
# endif  // __has_feature(thread_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
#endif  // __clang__

shiqian's avatar
shiqian committed
1041
1042
1043
1044
namespace testing {

class Message;

billydonahue's avatar
billydonahue committed
1045
#if defined(GTEST_TUPLE_NAMESPACE_)
1046
1047
1048
1049
1050
1051
1052
1053
// Import tuple and friends into the ::testing namespace.
// It is part of our interface, having them in ::testing allows us to change
// their types as needed.
using GTEST_TUPLE_NAMESPACE_::get;
using GTEST_TUPLE_NAMESPACE_::make_tuple;
using GTEST_TUPLE_NAMESPACE_::tuple;
using GTEST_TUPLE_NAMESPACE_::tuple_size;
using GTEST_TUPLE_NAMESPACE_::tuple_element;
billydonahue's avatar
billydonahue committed
1054
#endif  // defined(GTEST_TUPLE_NAMESPACE_)
1055

shiqian's avatar
shiqian committed
1056
1057
namespace internal {

1058
1059
1060
1061
1062
// A secret type that Google Test users don't know about.  It has no
// definition on purpose.  Therefore it's impossible to create a
// Secret object, which is what we want.
class Secret;

1063
1064
1065
1066
// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
// expression is true. For example, you could use it to verify the
// size of a static array:
//
1067
1068
//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
//                         names_incorrect_size);
1069
1070
1071
1072
1073
1074
1075
1076
1077
//
// or to make sure a struct is smaller than a certain size:
//
//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
//
// The second argument to the macro is the name of the variable. If
// the expression is false, most compilers will issue a warning/error
// containing the name of the variable.

1078
1079
1080
#if GTEST_LANG_CXX11
# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
#else  // !GTEST_LANG_CXX11
1081
template <bool>
1082
  struct CompileAssert {
1083
1084
};

1085
# define GTEST_COMPILE_ASSERT_(expr, msg) \
1086
1087
  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
1088
#endif  // !GTEST_LANG_CXX11
1089
1090
1091

// Implementation details of GTEST_COMPILE_ASSERT_:
//
1092
1093
// (In C++11, we simply use static_assert instead of the following)
//
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
//   elements (and thus is invalid) when the expression is false.
//
// - The simpler definition
//
//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
//
//   does not work, as gcc supports variable-length arrays whose sizes
//   are determined at run-time (this is gcc's extension and not part
//   of the C++ standard).  As a result, gcc fails to reject the
//   following code with the simple definition:
//
//     int foo;
//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
//                                      // not a compile-time constant.
//
// - By using the type CompileAssert<(bool(expr))>, we ensures that
//   expr is a compile-time constant.  (Template arguments must be
//   determined at compile-time.)
//
// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
//
//     CompileAssert<bool(expr)>
//
//   instead, these compilers will refuse to compile
//
//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
//
//   (They seem to think the ">" in "5 > 0" marks the end of the
//   template argument list.)
//
// - The array size is (bool(expr) ? 1 : -1), instead of simply
//
//     ((expr) ? 1 : -1).
//
//   This is to avoid running into a bug in MS VC 7.1, which
//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.

// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
//
// This template is declared, but intentionally undefined.
template <typename T1, typename T2>
struct StaticAssertTypeEqHelper;

template <typename T>
billydonahue's avatar
billydonahue committed
1140
1141
1142
struct StaticAssertTypeEqHelper<T, T> {
  enum { value = true };
};
1143

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
// Same as std::is_same<>.
template <typename T, typename U>
struct IsSame {
  enum { value = false };
};
template <typename T>
struct IsSame<T, T> {
  enum { value = true };
};

1154
1155
1156
// Evaluates to the number of elements in 'array'.
#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))

1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
#if GTEST_HAS_GLOBAL_STRING
typedef ::string string;
#else
typedef ::std::string string;
#endif  // GTEST_HAS_GLOBAL_STRING

#if GTEST_HAS_GLOBAL_WSTRING
typedef ::wstring wstring;
#elif GTEST_HAS_STD_WSTRING
typedef ::std::wstring wstring;
#endif  // GTEST_HAS_GLOBAL_WSTRING

1169
1170
// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
1171
GTEST_API_ bool IsTrue(bool condition);
1172

shiqian's avatar
shiqian committed
1173
1174
1175
1176
1177
1178
1179
// 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:
1180
1181
  typedef T element_type;

shiqian's avatar
shiqian committed
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
  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_) {
1197
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
shiqian's avatar
shiqian committed
1198
1199
1200
1201
1202
        delete ptr_;
      }
      ptr_ = p;
    }
  }
1203

billydonahue's avatar
billydonahue committed
1204
1205
1206
1207
1208
  friend void swap(scoped_ptr& a, scoped_ptr& b) {
    using std::swap;
    swap(a.ptr_, b.ptr_);
  }

shiqian's avatar
shiqian committed
1209
1210
1211
 private:
  T* ptr_;

shiqian's avatar
shiqian committed
1212
  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
shiqian's avatar
shiqian committed
1213
1214
};

1215
// Defines RE.
shiqian's avatar
shiqian committed
1216

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1217
1218
1219
1220
#if GTEST_USES_PCRE
using ::RE;
#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE

1221
// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
shiqian's avatar
shiqian committed
1222
// Regular Expression syntax.
1223
class GTEST_API_ RE {
shiqian's avatar
shiqian committed
1224
 public:
1225
1226
1227
1228
  // A copy constructor is required by the Standard to initialize object
  // references from r-values.
  RE(const RE& other) { Init(other.pattern()); }

shiqian's avatar
shiqian committed
1229
1230
1231
  // Constructs an RE from a string.
  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1232
# if GTEST_HAS_GLOBAL_STRING
1233

shiqian's avatar
shiqian committed
1234
  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
1235

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1236
# endif  // GTEST_HAS_GLOBAL_STRING
shiqian's avatar
shiqian committed
1237
1238
1239
1240
1241
1242
1243

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

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

1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
  // 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
1254
1255
1256
1257
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1258
# if GTEST_HAS_GLOBAL_STRING
1259

1260
1261
1262
  static bool FullMatch(const ::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
shiqian's avatar
shiqian committed
1263
1264
1265
  static bool PartialMatch(const ::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }
1266

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1267
# endif  // GTEST_HAS_GLOBAL_STRING
shiqian's avatar
shiqian committed
1268

1269
  static bool FullMatch(const char* str, const RE& re);
shiqian's avatar
shiqian committed
1270
1271
1272
1273
1274
  static bool PartialMatch(const char* str, const RE& re);

 private:
  void Init(const char* regex);

1275
1276
1277
  // We use a const char* instead of an std::string, as Google Test used to be
  // used where std::string is not available.  TODO(wan@google.com): change to
  // std::string.
shiqian's avatar
shiqian committed
1278
  const char* pattern_;
1279
  bool is_valid_;
1280

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1281
# if GTEST_USES_POSIX_RE
1282

1283
1284
  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().
1285

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1286
# else  // GTEST_USES_SIMPLE_RE
1287

1288
  const char* full_pattern_;  // For FullMatch();
1289

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1290
# endif
shiqian's avatar
shiqian committed
1291

1292
  GTEST_DISALLOW_ASSIGN_(RE);
1293
};
shiqian's avatar
shiqian committed
1294

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1295
1296
#endif  // GTEST_USES_PCRE

1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
// Formats a source file path and a line number as they would appear
// in an error message from the compiler used to compile this code.
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);

// Formats a file location for compiler-independent XML output.
// Although this function is not platform dependent, we put it next to
// FormatFileLocation in order to contrast the two functions.
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
                                                               int line);

shiqian's avatar
shiqian committed
1307
// Defines logging utilities:
1308
1309
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
shiqian's avatar
shiqian committed
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

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

1320
1321
1322
// 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.
1323
class GTEST_API_ GTestLog {
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
 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
1337

1338
1339
1340
#if !defined(GTEST_LOG_)

# define GTEST_LOG_(severity) \
1341
1342
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()
shiqian's avatar
shiqian committed
1343
1344
1345
1346

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

1347
1348
1349
#endif  // !defined(GTEST_LOG_)

#if !defined(GTEST_CHECK_)
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
// 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.
1364
# define GTEST_CHECK_(condition) \
1365
1366
1367
1368
1369
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::IsTrue(condition)) \
      ; \
    else \
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1370
#endif  // !defined(GTEST_CHECK_)
1371

1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
// 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

Gennadiy Civil's avatar
Gennadiy Civil committed
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
// Adds reference to a type if it is not a reference type,
// otherwise leaves it unchanged.  This is the same as
// tr1::add_reference, which is not widely available yet.
template <typename T>
struct AddReference { typedef T& type; };  // NOLINT
template <typename T>
struct AddReference<T&> { typedef T& type; };  // NOLINT

// A handy wrapper around AddReference that works when the argument T
// depends on template parameters.
#define GTEST_ADD_REFERENCE_(T) \
    typename ::testing::internal::AddReference<T>::type

// Transforms "T" into "const T&" according to standard reference collapsing
// rules (this is only needed as a backport for C++98 compilers that do not
// support reference collapsing). Specifically, it transforms:
//
//   char         ==> const char&
//   const char   ==> const char&
//   char&        ==> char&
//   const char&  ==> const char&
//
// Note that the non-const reference will not have "const" added. This is
// standard, and necessary so that "T" can always bind to "const T&".
template <typename T>
struct ConstRef { typedef const T& type; };
template <typename T>
struct ConstRef<T&> { typedef T& type; };

// The argument T must depend on some template parameters.
#define GTEST_REFERENCE_TO_CONST_(T) \
  typename ::testing::internal::ConstRef<T>::type

1415
#if GTEST_HAS_STD_MOVE_
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1416
using std::forward;
1417
using std::move;
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1418
1419
1420
1421
1422

template <typename T>
struct RvalueRef {
  typedef T&& type;
};
1423
#else  // GTEST_HAS_STD_MOVE_
1424
1425
1426
1427
template <typename T>
const T& move(const T& t) {
  return t;
}
Gennadiy Civil's avatar
Gennadiy Civil committed
1428
1429
template <typename T>
GTEST_ADD_REFERENCE_(T) forward(GTEST_ADD_REFERENCE_(T) t) { return t; }
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1430
1431
1432
1433
1434

template <typename T>
struct RvalueRef {
  typedef const T& type;
};
1435
1436
#endif  // GTEST_HAS_STD_MOVE_

1437
1438
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
1439
// Use ImplicitCast_ as a safe version of static_cast for upcasting in
1440
// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
1441
1442
// const Foo*).  When you use ImplicitCast_, the compiler checks that
// the cast is safe.  Such explicit ImplicitCast_s are necessary in
1443
1444
1445
// surprisingly many situations where C++ demands an exact type match
// instead of an argument type convertable to a target type.
//
1446
// The syntax for using ImplicitCast_ is the same as for static_cast:
1447
//
1448
//   ImplicitCast_<ToType>(expr)
1449
//
1450
// ImplicitCast_ would have been part of the C++ standard library,
1451
1452
// but the proposal was submitted too late.  It will probably make
// its way into the language in the future.
1453
1454
1455
1456
//
// This relatively ugly name is intentional. It prevents clashes with
// similar functions users may have (e.g., implicit_cast). The internal
// namespace alone is not enough because the function can be found by ADL.
1457
template<typename To>
kosak's avatar
kosak committed
1458
inline To ImplicitCast_(To x) { return x; }
1459
1460

// When you upcast (that is, cast a pointer from type Foo to type
1461
// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
// always succeed.  When you downcast (that is, cast a pointer from
// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
// how do you know the pointer is really of type SubclassOfFoo?  It
// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
// when you downcast, you should use this macro.  In debug mode, we
// use dynamic_cast<> to double-check the downcast is legal (we die
// if it's not).  In normal mode, we do the efficient static_cast<>
// instead.  Thus, it's important to test in debug mode to make sure
// the cast is legal!
//    This is the only place in the code we should use dynamic_cast<>.
// In particular, you SHOULDN'T be using dynamic_cast<> in order to
// do RTTI (eg code like this:
//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
// You should design the code some other way not to need this.
1477
1478
1479
1480
1481
1482
//
// This relatively ugly name is intentional. It prevents clashes with
// similar functions users may have (e.g., down_cast). The internal
// namespace alone is not enough because the function can be found by ADL.
template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
inline To DownCast_(From* f) {  // so we only accept pointers
1483
1484
1485
1486
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
billydonahue's avatar
billydonahue committed
1487
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
1488
  if (false) {
billydonahue's avatar
billydonahue committed
1489
  GTEST_INTENTIONAL_CONST_COND_POP_()
1490
    const To to = NULL;
1491
    ::testing::internal::ImplicitCast_<From*>(to);
1492
1493
1494
1495
1496
1497
1498
1499
1500
  }

#if GTEST_HAS_RTTI
  // RTTI: debug mode only!
  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
#endif
  return static_cast<To>(f);
}

1501
1502
1503
1504
1505
1506
1507
1508
1509
// Downcasts the pointer of type Base to Derived.
// Derived must be a subclass of Base. The parameter MUST
// point to a class of type Derived, not any subclass of it.
// When RTTI is available, the function performs a runtime
// check to enforce this.
template <class Derived, class Base>
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
1510
1511
1512
1513
1514
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
1515
1516
1517
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
1518
#endif
1519
1520
}

1521
#if GTEST_HAS_STREAM_REDIRECTION
1522

shiqian's avatar
shiqian committed
1523
// Defines the stderr capturer:
1524
1525
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
shiqian's avatar
shiqian committed
1526
1527
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
1528
//
zhanyong.wan's avatar
zhanyong.wan committed
1529
GTEST_API_ void CaptureStdout();
1530
GTEST_API_ std::string GetCapturedStdout();
zhanyong.wan's avatar
zhanyong.wan committed
1531
GTEST_API_ void CaptureStderr();
1532
GTEST_API_ std::string GetCapturedStderr();
1533

1534
#endif  // GTEST_HAS_STREAM_REDIRECTION
kosak's avatar
kosak committed
1535
1536
1537
1538
1539
// Returns the size (in bytes) of a file.
GTEST_API_ size_t GetFileSize(FILE* file);

// Reads the entire content of a file as a string.
GTEST_API_ std::string ReadEntireFile(FILE* file);
1540

1541
// All command line arguments.
Gennadiy Civil's avatar
Gennadiy Civil committed
1542
GTEST_API_ std::vector<std::string> GetArgvs();
1543

zhanyong.wan's avatar
zhanyong.wan committed
1544
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
1545

Gennadiy Civil's avatar
Gennadiy Civil committed
1546
1547
1548
1549
1550
1551
1552
1553
std::vector<std::string> GetInjectableArgvs();
// Deprecated: pass the args vector by value instead.
void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
#if GTEST_HAS_GLOBAL_STRING
void SetInjectableArgvs(const std::vector< ::string>& new_argvs);
#endif  // GTEST_HAS_GLOBAL_STRING
void ClearInjectableArgvs();
shiqian's avatar
shiqian committed
1554
1555
1556
1557

#endif  // GTEST_HAS_DEATH_TEST

// Defines synchronization primitives.
1558
1559
1560
1561
1562
#if GTEST_IS_THREADSAFE
# if GTEST_HAS_PTHREAD
// Sleeps for (roughly) n milliseconds.  This function is only for testing
// Google Test's own constructs.  Don't use it in user tests, either
// directly or indirectly.
1563
1564
1565
1566
1567
1568
1569
inline void SleepMilliseconds(int n) {
  const timespec time = {
    0,                  // 0 seconds.
    n * 1000L * 1000L,  // And n ms.
  };
  nanosleep(&time, NULL);
}
1570
# endif  // GTEST_HAS_PTHREAD
1571

1572
1573
1574
1575
# if GTEST_HAS_NOTIFICATION_
// Notification has already been imported into the namespace.
// Nothing to do here.

1576
# elif GTEST_HAS_PTHREAD
1577
1578
1579
1580
1581
1582
1583
1584
// 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:
jgm's avatar
jgm committed
1585
1586
1587
1588
1589
1590
  Notification() : notified_(false) {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
  }
  ~Notification() {
    pthread_mutex_destroy(&mutex_);
  }
1591
1592
1593

  // Notifies all threads created with this notification to start. Must
  // be called from the controller thread.
jgm's avatar
jgm committed
1594
1595
1596
1597
1598
  void Notify() {
    pthread_mutex_lock(&mutex_);
    notified_ = true;
    pthread_mutex_unlock(&mutex_);
  }
1599
1600
1601
1602

  // Blocks until the controller thread notifies. Must be called from a test
  // thread.
  void WaitForNotification() {
jgm's avatar
jgm committed
1603
1604
1605
1606
1607
1608
    for (;;) {
      pthread_mutex_lock(&mutex_);
      const bool notified = notified_;
      pthread_mutex_unlock(&mutex_);
      if (notified)
        break;
1609
1610
1611
1612
1613
      SleepMilliseconds(10);
    }
  }

 private:
jgm's avatar
jgm committed
1614
1615
  pthread_mutex_t mutex_;
  bool notified_;
1616
1617
1618
1619

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
};

1620
# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668

GTEST_API_ void SleepMilliseconds(int n);

// Provides leak-safe Windows kernel handle ownership.
// Used in death tests and in threading support.
class GTEST_API_ AutoHandle {
 public:
  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
  // avoid including <windows.h> in this header file. Including <windows.h> is
  // undesirable because it defines a lot of symbols and macros that tend to
  // conflict with client code. This assumption is verified by
  // WindowsTypesTest.HANDLEIsVoidStar.
  typedef void* Handle;
  AutoHandle();
  explicit AutoHandle(Handle handle);

  ~AutoHandle();

  Handle Get() const;
  void Reset();
  void Reset(Handle handle);

 private:
  // Returns true iff the handle is a valid handle object that can be closed.
  bool IsCloseable() const;

  Handle handle_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
};

// 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 GTEST_API_ Notification {
 public:
  Notification();
  void Notify();
  void WaitForNotification();

 private:
  AutoHandle event_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
};
1669
# endif  // GTEST_HAS_NOTIFICATION_
1670
1671
1672
1673
1674
1675

// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
// defined, but we don't want to use MinGW's pthreads implementation, which
// has conformance problems with some versions of the POSIX standard.
# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW

1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
// Consequently, it cannot select a correct instantiation of ThreadWithParam
// in order to call its Run(). Introducing ThreadWithParamBase as a
// non-templated base class for ThreadWithParam allows us to bypass this
// problem.
class ThreadWithParamBase {
 public:
  virtual ~ThreadWithParamBase() {}
  virtual void Run() = 0;
};

// pthread_create() accepts a pointer to a function type with the C linkage.
// According to the Standard (7.5/1), function types with different linkages
// are different even if they are otherwise identical.  Some compilers (for
// example, SunStudio) treat them as different types.  Since class methods
// cannot be defined with C-linkage we need to define a free C-function to
// pass into pthread_create().
extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
  static_cast<ThreadWithParamBase*>(thread)->Run();
  return NULL;
}

1698
// Helper class for testing Google Test's multi-threading constructs.
zhanyong.wan's avatar
zhanyong.wan committed
1699
// To use it, write:
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
//
//   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>
1711
class ThreadWithParam : public ThreadWithParamBase {
1712
 public:
1713
  typedef void UserThreadFunc(T);
1714

1715
  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1716
1717
1718
      : func_(func),
        param_(param),
        thread_can_start_(thread_can_start),
zhanyong.wan's avatar
zhanyong.wan committed
1719
        finished_(false) {
1720
    ThreadWithParamBase* const base = this;
zhanyong.wan's avatar
zhanyong.wan committed
1721
1722
1723
    // The thread can be created only after all fields except thread_
    // have been initialized.
    GTEST_CHECK_POSIX_SUCCESS_(
1724
        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
zhanyong.wan's avatar
zhanyong.wan committed
1725
1726
  }
  ~ThreadWithParam() { Join(); }
1727
1728
1729

  void Join() {
    if (!finished_) {
zhanyong.wan's avatar
zhanyong.wan committed
1730
      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
1731
1732
1733
1734
      finished_ = true;
    }
  }

1735
  virtual void Run() {
1736
1737
1738
1739
1740
    if (thread_can_start_ != NULL)
      thread_can_start_->WaitForNotification();
    func_(param_);
  }

1741
 private:
1742
  UserThreadFunc* const func_;  // User-supplied thread function.
1743
1744
1745
1746
1747
  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
1748
1749
1750
  pthread_t thread_;  // The native thread object.

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1751
};
1752
1753
1754
1755
1756
1757
# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_

# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
// Mutex and ThreadLocal have already been imported into the namespace.
// Nothing to do here.
1758

1759
# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1760

1761
1762
// Mutex implements mutex on Windows platforms.  It is used in conjunction
// with class MutexLock:
1763
//
1764
1765
//   Mutex mutex;
//   ...
1766
1767
//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
//                            // end of the current scope.
1768
//
1769
1770
// A static Mutex *must* be defined or declared using one of the following
// macros:
1771
//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
//
// (A non-static Mutex is defined/declared in the usual way).
class GTEST_API_ Mutex {
 public:
  enum MutexType { kStatic = 0, kDynamic = 1 };
  // We rely on kStaticMutex being 0 as it is to what the linker initializes
  // type_ in static mutexes.  critical_section_ will be initialized lazily
  // in ThreadSafeLazyInit().
  enum StaticConstructorSelector { kStaticMutex = 0 };

  // This constructor intentionally does nothing.  It relies on type_ being
  // statically initialized to 0 (effectively setting it to kStatic) and on
  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
  explicit Mutex(StaticConstructorSelector /*dummy*/) {}

  Mutex();
  ~Mutex();

  void Lock();

  void Unlock();

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
  void AssertHeld();

 private:
  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
  void ThreadSafeLazyInit();

  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
  // we assume that 0 is an invalid value for thread IDs.
  unsigned int owner_thread_id_;

  // For static mutexes, we rely on these members being initialized to zeros
  // by the linker.
  MutexType type_;
  long critical_section_init_phase_;  // NOLINT
1811
  GTEST_CRITICAL_SECTION* critical_section_;
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
    extern ::testing::internal::Mutex mutex

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

// We cannot name this class MutexLock because the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex* mutex)
      : mutex_(mutex) { mutex_->Lock(); }

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

 private:
  Mutex* const mutex_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
};

typedef GTestMutexLock MutexLock;

// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
// without knowing its type.
class ThreadLocalValueHolderBase {
 public:
  virtual ~ThreadLocalValueHolderBase() {}
};

// Provides a way for a thread to send notifications to a ThreadLocal
// regardless of its parameter type.
class ThreadLocalBase {
 public:
  // Creates a new ValueHolder<T> object holding a default value passed to
  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
  // responsibility not to call this when the ThreadLocal<T> instance already
  // has a value on the current thread.
  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;

 protected:
  ThreadLocalBase() {}
  virtual ~ThreadLocalBase() {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
};

// Maps a thread to a set of ThreadLocals that have values instantiated on that
// thread and notifies them when the thread exits.  A ThreadLocal instance is
// expected to persist until all threads it has values on have terminated.
class GTEST_API_ ThreadLocalRegistry {
 public:
  // Registers thread_local_instance as having value on the current thread.
  // Returns a value that can be used to identify the thread from other threads.
  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
      const ThreadLocalBase* thread_local_instance);

  // Invoked when a ThreadLocal instance is destroyed.
  static void OnThreadLocalDestroyed(
      const ThreadLocalBase* thread_local_instance);
};

class GTEST_API_ ThreadWithParamBase {
 public:
  void Join();

 protected:
  class Runnable {
   public:
    virtual ~Runnable() {}
    virtual void Run() = 0;
  };

  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
  virtual ~ThreadWithParamBase();

 private:
  AutoHandle thread_;
};

// Helper class for testing Google Test's multi-threading constructs.
template <typename T>
class ThreadWithParam : public ThreadWithParamBase {
 public:
  typedef void UserThreadFunc(T);

  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
  }
  virtual ~ThreadWithParam() {}

 private:
  class RunnableImpl : public Runnable {
   public:
    RunnableImpl(UserThreadFunc* func, T param)
        : func_(func),
          param_(param) {
    }
    virtual ~RunnableImpl() {}
    virtual void Run() {
      func_(param_);
    }

   private:
    UserThreadFunc* const func_;
    const T param_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
  };

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
};

// Implements thread-local storage on Windows systems.
//
//   // Thread 1
//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
1937
//
1938
1939
1940
//   // Thread 2
//   tl.set(150);  // Changes the value for thread 2 only.
//   EXPECT_EQ(150, tl.get());
1941
//
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
//   // Thread 1
//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
//   tl.set(200);
//   EXPECT_EQ(200, tl.get());
//
// 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.
//
// The users of a TheadLocal instance have to make sure that all but one
// threads (including the main one) using that instance have exited before
// destroying it. Otherwise, the per-thread objects managed for them by the
// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
1955
//
1956
1957
1958
1959
1960
1961
1962
// Google Test only uses global ThreadLocal objects.  That means they
// will die after main() has returned.  Therefore, no per-thread
// object managed by Google Test will be leaked as long as all threads
// using Google Test have exited when main() returns.
template <typename T>
class ThreadLocal : public ThreadLocalBase {
 public:
1963
1964
1965
  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
  explicit ThreadLocal(const T& value)
      : default_factory_(new InstanceValueHolderFactory(value)) {}
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978

  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }

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

 private:
  // Holds a value of T.  Can be deleted via its base class without the caller
  // knowing the type of T.
  class ValueHolder : public ThreadLocalValueHolderBase {
   public:
1979
    ValueHolder() : value_() {}
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
    explicit ValueHolder(const T& value) : value_(value) {}

    T* pointer() { return &value_; }

   private:
    T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
  };


  T* GetOrCreateValue() const {
    return static_cast<ValueHolder*>(
        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
  }

  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
1996
    return default_factory_->MakeNewHolder();
1997
1998
  }

1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
  class ValueHolderFactory {
   public:
    ValueHolderFactory() {}
    virtual ~ValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const = 0;

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
  };

  class DefaultValueHolderFactory : public ValueHolderFactory {
   public:
    DefaultValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
  };

  class InstanceValueHolderFactory : public ValueHolderFactory {
   public:
    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
    virtual ValueHolder* MakeNewHolder() const {
      return new ValueHolder(value_);
    }

   private:
    const T value_;  // The value for each thread.

    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
  };

  scoped_ptr<ValueHolderFactory> default_factory_;
2032
2033
2034
2035
2036
2037
2038

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

# elif GTEST_HAS_PTHREAD

// MutexBase and Mutex implement mutex on pthreads-based platforms.
2039
2040
class MutexBase {
 public:
2041
2042
2043
2044
  // Acquires this mutex.
  void Lock() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
    owner_ = pthread_self();
2045
    has_owner_ = true;
2046
2047
2048
2049
  }

  // Releases this mutex.
  void Unlock() {
2050
2051
2052
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
2053
    // mutex when this is called.
2054
    has_owner_ = false;
2055
2056
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }
2057
2058
2059

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
2060
  void AssertHeld() const {
2061
    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
2062
2063
        << "The current thread is not holding the mutex @" << this;
  }
2064

2065
2066
2067
2068
2069
  // 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.
2070
 public:
2071
  pthread_mutex_t mutex_;  // The underlying pthread mutex.
2072
2073
2074
2075
2076
2077
2078
2079
  // has_owner_ indicates whether the owner_ field below contains a valid thread
  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
  // accesses to the owner_ field should be protected by a check of this field.
  // An alternative might be to memset() owner_ to all zeros, but there's no
  // guarantee that a zero'd pthread_t is necessarily invalid or even different
  // from pthread_self().
  bool has_owner_;
  pthread_t owner_;  // The thread holding the mutex.
2080
2081
2082
};

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

2086
// Defines and statically (i.e. at link time) initializes a static mutex.
2087
2088
2089
2090
2091
// The initialization list here does not explicitly initialize each field,
// instead relying on default initialization for the unspecified fields. In
// particular, the owner_ field (a pthread_t) is not explicitly initialized.
// This allows initialization to work whether pthread_t is a scalar or struct.
// The flag -Wmissing-field-initializers must not be specified for this to work.
2092
#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
2093
     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
2094

2095
2096
// The Mutex class can only be used for mutexes created at runtime. It
// shares its API with MutexBase otherwise.
2097
2098
class Mutex : public MutexBase {
 public:
2099
2100
  Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2101
    has_owner_ = false;
2102
2103
2104
2105
  }
  ~Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
  }
2106
2107
2108
2109
2110

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

2111
// We cannot name this class MutexLock because the ctor declaration would
2112
// conflict with a macro named MutexLock, which is defined on some
2113
2114
2115
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
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;

2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
// Helpers for ThreadLocal.

// pthread_key_create() requires DeleteThreadLocalValue() to have
// C-linkage.  Therefore it cannot be templatized to access
// ThreadLocal<T>.  Hence the need for class
// ThreadLocalValueHolderBase.
class ThreadLocalValueHolderBase {
 public:
  virtual ~ThreadLocalValueHolderBase() {}
};

// Called by pthread to delete thread-local data stored by
// pthread_setspecific().
extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
}

2148
2149
// Implements thread-local storage on pthreads-based systems.
template <typename T>
2150
class GTEST_API_ ThreadLocal {
2151
 public:
2152
2153
2154
2155
2156
  ThreadLocal()
      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
  explicit ThreadLocal(const T& value)
      : key_(CreateKey()),
        default_factory_(new InstanceValueHolderFactory(value)) {}
2157
2158

  ~ThreadLocal() {
zhanyong.wan's avatar
zhanyong.wan committed
2159
2160
2161
2162
2163
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
2164
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
2165
2166
2167
2168
2169
2170
2171
2172
  }

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

 private:
2173
2174
2175
  // Holds a value of type T.
  class ValueHolder : public ThreadLocalValueHolderBase {
   public:
2176
    ValueHolder() : value_() {}
2177
2178
2179
2180
2181
2182
2183
2184
2185
    explicit ValueHolder(const T& value) : value_(value) {}

    T* pointer() { return &value_; }

   private:
    T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
  };

2186
2187
  static pthread_key_t CreateKey() {
    pthread_key_t key;
zhanyong.wan's avatar
zhanyong.wan committed
2188
2189
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
2190
2191
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
2192
2193
2194
2195
    return key;
  }

  T* GetOrCreateValue() const {
2196
2197
2198
2199
2200
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }
2201

2202
    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
2203
2204
2205
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
2206
2207
  }

2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
  class ValueHolderFactory {
   public:
    ValueHolderFactory() {}
    virtual ~ValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const = 0;

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
  };

  class DefaultValueHolderFactory : public ValueHolderFactory {
   public:
    DefaultValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
  };

  class InstanceValueHolderFactory : public ValueHolderFactory {
   public:
    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
    virtual ValueHolder* MakeNewHolder() const {
      return new ValueHolder(value_);
    }

   private:
    const T value_;  // The value for each thread.

    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
  };

2240
2241
  // A key pthreads uses for looking up per-thread values.
  const pthread_key_t key_;
2242
  scoped_ptr<ValueHolderFactory> default_factory_;
2243
2244
2245
2246

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

2247
# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
2248

2249
#else  // GTEST_IS_THREADSAFE
2250

shiqian's avatar
shiqian committed
2251
2252
2253
2254
2255
2256
2257
2258
// 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() {}
2259
2260
  void Lock() {}
  void Unlock() {}
shiqian's avatar
shiqian committed
2261
2262
2263
  void AssertHeld() const {}
};

2264
# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2265
2266
  extern ::testing::internal::Mutex mutex

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

2269
2270
2271
2272
2273
// We cannot name this class MutexLock because the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
shiqian's avatar
shiqian committed
2274
2275
2276
2277
2278
2279
2280
2281
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex*) {}  // NOLINT
};

typedef GTestMutexLock MutexLock;

template <typename T>
2282
class GTEST_API_ ThreadLocal {
shiqian's avatar
shiqian committed
2283
 public:
shiqian's avatar
shiqian committed
2284
2285
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
shiqian's avatar
shiqian committed
2286
2287
2288
2289
2290
2291
2292
2293
  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_;
};

2294
#endif  // GTEST_IS_THREADSAFE
2295
2296
2297

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
zhanyong.wan's avatar
zhanyong.wan committed
2298
GTEST_API_ size_t GetThreadCount();
2299

2300
// Passing non-POD classes through ellipsis (...) crashes the ARM
2301
// compiler and generates a warning in Sun Studio before 12u4. The Nokia Symbian
2302
2303
2304
2305
// 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.
2306
2307
#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || \
     (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5130)
2308
2309
// We lose support for NULL detection where the compiler doesn't like
// passing non-POD classes through ellipsis (...).
2310
# define GTEST_ELLIPSIS_NEEDS_POD_ 1
2311
#else
2312
# define GTEST_CAN_COMPARE_NULL 1
2313
#endif
shiqian's avatar
shiqian committed
2314

2315
2316
2317
2318
// 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.
2319
#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
2320
# define GTEST_NEEDS_IS_POINTER_ 1
2321
#endif
shiqian's avatar
shiqian committed
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332

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;

2333
2334
2335
2336
2337
2338
template <typename T, typename U>
struct is_same : public false_type {};

template <typename T>
struct is_same<T, T> : public true_type {};

Gennadiy Civil's avatar
Gennadiy Civil committed
2339

shiqian's avatar
shiqian committed
2340
2341
2342
2343
2344
2345
template <typename T>
struct is_pointer : public false_type {};

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

2346
2347
2348
2349
2350
template <typename Iterator>
struct IteratorTraits {
  typedef typename Iterator::value_type value_type;
};

Gennadiy Civil's avatar
Gennadiy Civil committed
2351

2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
template <typename T>
struct IteratorTraits<T*> {
  typedef T value_type;
};

template <typename T>
struct IteratorTraits<const T*> {
  typedef T value_type;
};

2362
#if GTEST_OS_WINDOWS
2363
2364
# define GTEST_PATH_SEP_ "\\"
# define GTEST_HAS_ALT_PATH_SEP_ 1
2365
2366
// The biggest signed integer type the compiler supports.
typedef __int64 BiggestInt;
2367
#else
2368
2369
# define GTEST_PATH_SEP_ "/"
# define GTEST_HAS_ALT_PATH_SEP_ 0
2370
typedef long long BiggestInt;  // NOLINT
2371
2372
#endif  // GTEST_OS_WINDOWS

2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
// Utilities for char.

// isspace(int ch) and friends accept an unsigned char or EOF.  char
// may be signed, depending on the compiler (or compiler flags).
// Therefore we need to cast a char to unsigned char before calling
// isspace(), etc.

inline bool IsAlpha(char ch) {
  return isalpha(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsAlNum(char ch) {
  return isalnum(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsDigit(char ch) {
  return isdigit(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsLower(char ch) {
  return islower(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsSpace(char ch) {
  return isspace(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsUpper(char ch) {
  return isupper(static_cast<unsigned char>(ch)) != 0;
}
2398
2399
2400
inline bool IsXDigit(char ch) {
  return isxdigit(static_cast<unsigned char>(ch)) != 0;
}
2401
2402
2403
2404
inline bool IsXDigit(wchar_t ch) {
  const unsigned char low_byte = static_cast<unsigned char>(ch);
  return ch == low_byte && isxdigit(low_byte) != 0;
}
2405
2406
2407
2408
2409
2410
2411
2412

inline char ToLower(char ch) {
  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
}
inline char ToUpper(char ch) {
  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
}

2413
2414
2415
2416
2417
2418
2419
inline std::string StripTrailingSpaces(std::string str) {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

2420
2421
// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
2422
2423
2424
2425
// 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.

2426
2427
2428
2429
namespace posix {

// Functions with a different name on Windows.

zhanyong.wan's avatar
zhanyong.wan committed
2430
#if GTEST_OS_WINDOWS
2431

2432
typedef struct _stat StatStruct;
2433

2434
# ifdef __BORLANDC__
2435
2436
2437
2438
2439
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); }
2440
2441
# else  // !__BORLANDC__
#  if GTEST_OS_WINDOWS_MOBILE
2442
inline int IsATTY(int /* fd */) { return 0; }
2443
#  else
2444
inline int IsATTY(int fd) { return _isatty(fd); }
2445
#  endif  // GTEST_OS_WINDOWS_MOBILE
2446
2447
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
2448
}
2449
inline char* StrDup(const char* src) { return _strdup(src); }
2450
# endif  // __BORLANDC__
2451

2452
# if GTEST_OS_WINDOWS_MOBILE
2453
2454
2455
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.
2456
# else
2457
2458
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
2459
2460
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
2461
2462
  return (_S_IFDIR & st.st_mode) != 0;
}
2463
# endif  // GTEST_OS_WINDOWS_MOBILE
2464

shiqian's avatar
shiqian committed
2465
#else
2466

2467
typedef struct stat StatStruct;
2468

2469
2470
2471
2472
2473
2474
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);
}
2475
inline char* StrDup(const char* src) { return strdup(src); }
2476
2477
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
2478

shiqian's avatar
shiqian committed
2479
2480
#endif  // GTEST_OS_WINDOWS

2481
2482
// Functions deprecated by MSVC 8.0.

billydonahue's avatar
billydonahue committed
2483
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
2484

2485
2486
inline const char* StrNCpy(char* dest, const char* src, size_t n) {
  return strncpy(dest, src, n);
2487
}
2488
2489
2490
2491
2492

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

billydonahue's avatar
billydonahue committed
2493
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
2494
inline int ChDir(const char* dir) { return chdir(dir); }
2495
#endif
2496
2497
inline FILE* FOpen(const char* path, const char* mode) {
  return fopen(path, mode);
2498
}
2499
#if !GTEST_OS_WINDOWS_MOBILE
2500
2501
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
2502
}
2503
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
2504
#endif
2505
inline int FClose(FILE* fp) { return fclose(fp); }
2506
#if !GTEST_OS_WINDOWS_MOBILE
2507
2508
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
2509
}
2510
2511
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
2512
}
2513
2514
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
2515
#endif
2516
inline const char* GetEnv(const char* name) {
2517
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
2518
  // We are on Windows CE, which has no environment variables.
2519
  static_cast<void>(name);  // To prevent 'unused argument' warning.
2520
  return NULL;
2521
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2522
2523
2524
2525
  // 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;
2526
#else
2527
  return getenv(name);
2528
2529
2530
#endif
}

billydonahue's avatar
billydonahue committed
2531
GTEST_DISABLE_MSC_WARNINGS_POP_()
2532

2533
#if GTEST_OS_WINDOWS_MOBILE
2534
2535
2536
// 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.
2537
void Abort();
2538
#else
2539
inline void Abort() { abort(); }
2540
#endif  // GTEST_OS_WINDOWS_MOBILE
2541
2542
2543

}  // namespace posix

2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
// function in order to achieve that.  We use macro definition here because
// snprintf is a variadic function.
#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
// MSVC 2005 and above support variadic macros.
# define GTEST_SNPRINTF_(buffer, size, format, ...) \
     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
#elif defined(_MSC_VER)
// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
// complain about _snprintf.
# define GTEST_SNPRINTF_ _snprintf
#else
# define GTEST_SNPRINTF_ snprintf
#endif

shiqian's avatar
shiqian committed
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
// 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
2613
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
  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.
2632
2633
2634
#if !defined(GTEST_FLAG)
# define GTEST_FLAG(name) FLAGS_gtest_##name
#endif  // !defined(GTEST_FLAG)
shiqian's avatar
shiqian committed
2635

kosak's avatar
kosak committed
2636
2637
2638
2639
#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)

2640
#if !defined(GTEST_DECLARE_bool_)
2641
2642
# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver

shiqian's avatar
shiqian committed
2643
// Macros for declaring flags.
2644
2645
# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
# define GTEST_DECLARE_int32_(name) \
2646
    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
2647
# define GTEST_DECLARE_string_(name) \
2648
    GTEST_API_ extern ::std::string GTEST_FLAG(name)
shiqian's avatar
shiqian committed
2649
2650

// Macros for defining flags.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
2651
# define GTEST_DEFINE_bool_(name, default_val, doc) \
2652
    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
2653
# define GTEST_DEFINE_int32_(name, default_val, doc) \
2654
    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
2655
# define GTEST_DEFINE_string_(name, default_val, doc) \
2656
    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
shiqian's avatar
shiqian committed
2657

2658
2659
#endif  // !defined(GTEST_DECLARE_bool_)

2660
// Thread annotations
2661
2662
2663
2664
#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
# define GTEST_LOCK_EXCLUDED_(locks)
#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2665

shiqian's avatar
shiqian committed
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
// 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);
zhanyong.wan's avatar
zhanyong.wan committed
2677
GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
Gennadiy Civil's avatar
Gennadiy Civil committed
2678
std::string OutputFlagAlsoCheckEnvVar();
Gennadiy Civil's avatar
Gennadiy Civil committed
2679
const char* StringFromGTestEnv(const char* flag, const char* default_val);
shiqian's avatar
shiqian committed
2680
2681
2682
2683
2684

}  // namespace internal
}  // namespace testing

#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_