gtest-port.h revision bbab12725025270beb12cb62a73b9cfc33bdec85
1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc.
2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved.
3d201456903f3ecae1f7794edfab0d5678e64226shiqian//
4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without
5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are
6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met:
7d201456903f3ecae1f7794edfab0d5678e64226shiqian//
8d201456903f3ecae1f7794edfab0d5678e64226shiqian//     * Redistributions of source code must retain the above copyright
9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer.
10d201456903f3ecae1f7794edfab0d5678e64226shiqian//     * Redistributions in binary form must reproduce the above
11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer
12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the
13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution.
14d201456903f3ecae1f7794edfab0d5678e64226shiqian//     * Neither the name of Google Inc. nor the names of its
15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from
16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission.
17d201456903f3ecae1f7794edfab0d5678e64226shiqian//
18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29d201456903f3ecae1f7794edfab0d5678e64226shiqian//
30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Authors: wan@google.com (Zhanyong Wan)
31d201456903f3ecae1f7794edfab0d5678e64226shiqian//
32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Low-level types and utilities for porting Google Test to various
33d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms.  They are subject to change without notice.  DO NOT USE
34d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEM IN USER CODE.
35d201456903f3ecae1f7794edfab0d5678e64226shiqian
36d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
37d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
38d201456903f3ecae1f7794edfab0d5678e64226shiqian
39d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user can define the following macros in the build script to
40e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// control Google Test's behavior.  If the user doesn't define a macro
41e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// in this list, Google Test will define it.
42d201456903f3ecae1f7794edfab0d5678e64226shiqian//
4304f025dd5746fca83c6c32f1729b3449721dd60eshiqian//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
4404f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              is/isn't available.
45d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
46d201456903f3ecae1f7794edfab0d5678e64226shiqian//                              is/isn't available (some systems define
47d201456903f3ecae1f7794edfab0d5678e64226shiqian//                              ::string, which is different to std::string).
48d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
49d201456903f3ecae1f7794edfab0d5678e64226shiqian//                              is/isn't available (some systems define
50d201456903f3ecae1f7794edfab0d5678e64226shiqian//                              ::wstring, which is different to std::wstring).
51e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
52e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//                              is/isn't available.
5304f025dd5746fca83c6c32f1729b3449721dd60eshiqian//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
5404f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              enabled.
5504f025dd5746fca83c6c32f1729b3449721dd60eshiqian//   GTEST_HAS_STD_STRING     - Define it to 1/0 to indicate that
5604f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              std::string does/doesn't work (Google Test can
5704f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              be used where std::string is unavailable).
5804f025dd5746fca83c6c32f1729b3449721dd60eshiqian//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
5904f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              std::wstring does/doesn't work (Google Test can
6004f025dd5746fca83c6c32f1729b3449721dd60eshiqian//                              be used where std::wstring is unavailable).
613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//   GTEST_HAS_TR1_TUPLE 1    - Define it to 1/0 to indicate tr1::tuple
623d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//                              is/isn't available.
63d201456903f3ecae1f7794edfab0d5678e64226shiqian
64d201456903f3ecae1f7794edfab0d5678e64226shiqian// This header defines the following utilities:
65d201456903f3ecae1f7794edfab0d5678e64226shiqian//
66d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros indicating the name of the Google C++ Testing Framework project:
67d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_NAME              - a string literal of the project name.
68d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_FLAG_PREFIX       - a string literal of the prefix all Google
69d201456903f3ecae1f7794edfab0d5678e64226shiqian//                             Test flag names share.
70d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_FLAG_PREFIX_UPPER - a string literal of the prefix all Google
71d201456903f3ecae1f7794edfab0d5678e64226shiqian//                             Test flag names share, in upper case.
72d201456903f3ecae1f7794edfab0d5678e64226shiqian//
73d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros indicating the current platform:
74e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian//   GTEST_OS_CYGWIN   - defined iff compiled on Cygwin.
75d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_OS_LINUX    - defined iff compiled on Linux.
76d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_OS_MAC      - defined iff compiled on Mac OS X.
77d2849f573052ba8431a887e0034b1be353a0d9b4shiqian//   GTEST_OS_SOLARIS  - defined iff compiled on Sun Solaris.
78e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_OS_SYMBIAN  - defined iff compiled for Symbian.
79d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_OS_WINDOWS  - defined iff compiled on Windows.
80d2849f573052ba8431a887e0034b1be353a0d9b4shiqian//   GTEST_OS_ZOS      - defined iff compiled on IBM z/OS.
81d2849f573052ba8431a887e0034b1be353a0d9b4shiqian//
82b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
83b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// most stable support.  Since core members of the Google Test project
84b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// don't have access to other platforms, support for them may be less
85b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// stable.  If you notice any problems on your platform, please notify
86b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// googletestframework@googlegroups.com (patches for fixing them are
87b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// even more welcome!).
88b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian//
89d201456903f3ecae1f7794edfab0d5678e64226shiqian// Note that it is possible that none of the GTEST_OS_ macros are defined.
90d201456903f3ecae1f7794edfab0d5678e64226shiqian//
91d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros indicating available Google Test features:
923d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//   GTEST_HAS_COMBINE      - defined iff Combine construct is supported
933d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//                            in value-parameterized tests.
94a2b1a8556ea64014606d78b09333d9c522430a25shiqian//   GTEST_HAS_DEATH_TEST   - defined iff death tests are supported.
953d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//   GTEST_HAS_PARAM_TEST   - defined iff value-parameterized tests are
963d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//                            supported.
97a2b1a8556ea64014606d78b09333d9c522430a25shiqian//   GTEST_HAS_TYPED_TEST   - defined iff typed tests are supported.
98a2b1a8556ea64014606d78b09333d9c522430a25shiqian//   GTEST_HAS_TYPED_TEST_P - defined iff type-parameterized tests are
99a2b1a8556ea64014606d78b09333d9c522430a25shiqian//                            supported.
100d201456903f3ecae1f7794edfab0d5678e64226shiqian//
101d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for basic C++ coding:
102e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
103e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances don't have to
104e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//                              be used.
105e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
106e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
107d201456903f3ecae1f7794edfab0d5678e64226shiqian//
108d201456903f3ecae1f7794edfab0d5678e64226shiqian// Synchronization:
109d201456903f3ecae1f7794edfab0d5678e64226shiqian//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
110d201456903f3ecae1f7794edfab0d5678e64226shiqian//                  - synchronization primitives.
111e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
112e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//                         synchronization primitives have real implementations
113e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//                         and Google Test is thread-safe; or 0 otherwise.
114d201456903f3ecae1f7794edfab0d5678e64226shiqian//
115d201456903f3ecae1f7794edfab0d5678e64226shiqian// Template meta programming:
116d2849f573052ba8431a887e0034b1be353a0d9b4shiqian//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
117d201456903f3ecae1f7794edfab0d5678e64226shiqian//
118d201456903f3ecae1f7794edfab0d5678e64226shiqian// Smart pointers:
119d201456903f3ecae1f7794edfab0d5678e64226shiqian//   scoped_ptr     - as in TR2.
120d201456903f3ecae1f7794edfab0d5678e64226shiqian//
121d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular expressions:
122d201456903f3ecae1f7794edfab0d5678e64226shiqian//   RE             - a simple regular expression class using the POSIX
123d201456903f3ecae1f7794edfab0d5678e64226shiqian//                    Extended Regular Expression syntax.  Not available on
124d201456903f3ecae1f7794edfab0d5678e64226shiqian//                    Windows.
125d201456903f3ecae1f7794edfab0d5678e64226shiqian//
126d201456903f3ecae1f7794edfab0d5678e64226shiqian// Logging:
127e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_LOG_()   - logs messages at the specified severity level.
128d201456903f3ecae1f7794edfab0d5678e64226shiqian//   LogToStderr()  - directs all log messages to stderr.
129d201456903f3ecae1f7794edfab0d5678e64226shiqian//   FlushInfoLog() - flushes informational log messages.
130d201456903f3ecae1f7794edfab0d5678e64226shiqian//
131d201456903f3ecae1f7794edfab0d5678e64226shiqian// Stderr capturing:
132d201456903f3ecae1f7794edfab0d5678e64226shiqian//   CaptureStderr()     - starts capturing stderr.
133d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GetCapturedStderr() - stops capturing stderr and returns the captured
134d201456903f3ecae1f7794edfab0d5678e64226shiqian//                         string.
135d201456903f3ecae1f7794edfab0d5678e64226shiqian//
136d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types:
137d201456903f3ecae1f7794edfab0d5678e64226shiqian//   TypeWithSize   - maps an integer to a int type.
138d201456903f3ecae1f7794edfab0d5678e64226shiqian//   Int32, UInt32, Int64, UInt64, TimeInMillis
139d201456903f3ecae1f7794edfab0d5678e64226shiqian//                  - integers of known sizes.
140d201456903f3ecae1f7794edfab0d5678e64226shiqian//   BiggestInt     - the biggest signed integer type.
141d201456903f3ecae1f7794edfab0d5678e64226shiqian//
142d201456903f3ecae1f7794edfab0d5678e64226shiqian// Command-line utilities:
143d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_FLAG()       - references a flag.
144d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_DECLARE_*()  - declares a flag.
145d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GTEST_DEFINE_*()   - defines a flag.
146d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GetArgvs()         - returns the command line as a vector of strings.
147d201456903f3ecae1f7794edfab0d5678e64226shiqian//
148d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variable utilities:
149d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GetEnv()             - gets the value of an environment variable.
150d201456903f3ecae1f7794edfab0d5678e64226shiqian//   BoolFromGTestEnv()   - parses a bool environment variable.
151d201456903f3ecae1f7794edfab0d5678e64226shiqian//   Int32FromGTestEnv()  - parses an Int32 environment variable.
152d201456903f3ecae1f7794edfab0d5678e64226shiqian//   StringFromGTestEnv() - parses a string environment variable.
153d201456903f3ecae1f7794edfab0d5678e64226shiqian
154d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h>
155d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdio.h>
1563d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#include <iostream>  // Used for GTEST_CHECK_
157d201456903f3ecae1f7794edfab0d5678e64226shiqian
158d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_NAME "Google Test"
159d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG_PREFIX "gtest_"
160d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG_PREFIX_UPPER "GTEST_"
161d201456903f3ecae1f7794edfab0d5678e64226shiqian
16264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines the version of gcc that is used to compile this.
16364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GNUC__
16464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// 40302 means version 4.3.2.
16564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_GCC_VER_ \
16664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
16764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // __GNUC__
16864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
169d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines the platform on which Google Test is compiled.
170e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#ifdef __CYGWIN__
171e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#define GTEST_OS_CYGWIN
172e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#elif __SYMBIAN32__
173e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_OS_SYMBIAN
174e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#elif defined _MSC_VER
175d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(kenton@google.com): GTEST_OS_WINDOWS is currently used to mean
176d201456903f3ecae1f7794edfab0d5678e64226shiqian//   both "The OS is Windows" and "The compiler is MSVC".  These
177d201456903f3ecae1f7794edfab0d5678e64226shiqian//   meanings really should be separated in order to better support
178d201456903f3ecae1f7794edfab0d5678e64226shiqian//   Windows compilers other than MSVC.
179d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_OS_WINDOWS
180d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __APPLE__
181d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_OS_MAC
182d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __linux__
183d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_OS_LINUX
184d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined __MVS__
185d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_OS_ZOS
186d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined(__sun) && defined(__SVR4)
187d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_OS_SOLARIS
188d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // _MSC_VER
189d201456903f3ecae1f7794edfab0d5678e64226shiqian
190d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines whether ::std::string and ::string are available.
191d201456903f3ecae1f7794edfab0d5678e64226shiqian
192d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_STD_STRING
193d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::std::string is available, so we
194d201456903f3ecae1f7794edfab0d5678e64226shiqian// need to figure it out.
195d201456903f3ecae1f7794edfab0d5678e64226shiqian
196d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS
197d201456903f3ecae1f7794edfab0d5678e64226shiqian// Assumes that exceptions are enabled by default.
198d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef _HAS_EXCEPTIONS
199d201456903f3ecae1f7794edfab0d5678e64226shiqian#define _HAS_EXCEPTIONS 1
200d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // _HAS_EXCEPTIONS
201d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_EXCEPTIONS is non-zero iff exceptions are enabled.  It is
202d201456903f3ecae1f7794edfab0d5678e64226shiqian// always defined, while _HAS_EXCEPTIONS is defined only on Windows.
203d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
204d201456903f3ecae1f7794edfab0d5678e64226shiqian// On Windows, we can use ::std::string if the compiler version is VS
205d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2005 or above, or if exceptions are enabled.
206d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_STRING ((_MSC_VER >= 1400) || GTEST_HAS_EXCEPTIONS)
207d201456903f3ecae1f7794edfab0d5678e64226shiqian#else  // We are on Linux or Mac OS.
208d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_EXCEPTIONS 0
209d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_STRING 1
210d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_OS_WINDOWS
211d201456903f3ecae1f7794edfab0d5678e64226shiqian
212d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING
213d201456903f3ecae1f7794edfab0d5678e64226shiqian
214d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_STRING
215d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::string is available, so we need
216d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out.
217d201456903f3ecae1f7794edfab0d5678e64226shiqian
218d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_GLOBAL_STRING 0
219d201456903f3ecae1f7794edfab0d5678e64226shiqian
220d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_GLOBAL_STRING
221d201456903f3ecae1f7794edfab0d5678e64226shiqian
222d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_STD_WSTRING
223d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::std::wstring is available, so we need
224d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out.
225d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
226d201456903f3ecae1f7794edfab0d5678e64226shiqian//   is available.
227d201456903f3ecae1f7794edfab0d5678e64226shiqian
228d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#if defined(GTEST_OS_CYGWIN) || defined(GTEST_OS_SOLARIS)
229bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.5 and below doesn't support ::std::wstring.
230bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.7 might add wstring support; this should be updated when clear.
231d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Solaris' libc++ doesn't support it either.
232d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_WSTRING 0
233d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
234d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING
235d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#endif  // defined(GTEST_OS_CYGWIN) || defined(GTEST_OS_SOLARIS)
236d201456903f3ecae1f7794edfab0d5678e64226shiqian
237d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_WSTRING
238d201456903f3ecae1f7794edfab0d5678e64226shiqian
239d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_WSTRING
240d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::wstring is available, so we need
241d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out.
242bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan#define GTEST_HAS_GLOBAL_WSTRING \
243bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
244d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_GLOBAL_WSTRING
245d201456903f3ecae1f7794edfab0d5678e64226shiqian
246d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \
247d201456903f3ecae1f7794edfab0d5678e64226shiqian    GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
248d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <string>  // NOLINT
249d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING ||
250d201456903f3ecae1f7794edfab0d5678e64226shiqian        // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
251d201456903f3ecae1f7794edfab0d5678e64226shiqian
252d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING
253d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <sstream>  // NOLINT
254d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
255d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <strstream>  // NOLINT
256d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING
257d201456903f3ecae1f7794edfab0d5678e64226shiqian
25864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines whether RTTI is available.
25964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifndef GTEST_HAS_RTTI
26064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// The user didn't tell us whether RTTI is enabled, so we need to
26164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// figure it out.
26264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
26364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _MSC_VER
26464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
26564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
26664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1
26764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else
26864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0
26964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // _CPPRTTI
27064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
27164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#elif defined(__GNUC__)
27264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
27364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
27464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if GTEST_GCC_VER_ >= 40302
27564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GXX_RTTI
27664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1
27764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else
27864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0
27964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // __GXX_RTTI
28064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else
28164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// For gcc versions smaller than 4.3.2, we assume RTTI is enabled.
28264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1
28364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // GTEST_GCC_VER >= 40302
28464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
28564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else
28664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
28764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Unknown compiler - assume RTTI is enabled.
28864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1
28964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
29064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // _MSC_VER
29164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
29264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // GTEST_HAS_RTTI
29364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian
294e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Determines whether <pthread.h> is available.
295e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#ifndef GTEST_HAS_PTHREAD
296e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The user didn't tell us, so we need to figure it out.
297e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian
298e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC)
299e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_HAS_PTHREAD 1
300e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#else
301e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_HAS_PTHREAD 0
302e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif  // GTEST_OS_LINUX || GTEST_OS_MAC
303e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian
304e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif  // GTEST_HAS_PTHREAD
305e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian
3065145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// Determines whether tr1/tuple is available.  If you have tr1/tuple
3073d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// on your platform, define GTEST_HAS_TR1_TUPLE=1 for both the Google
3083d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Test project and your tests. If you would like Google Test to detect
3095145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple on your platform automatically, please open an issue
3103d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// ticket at http://code.google.com/p/googletest.
3113d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#ifndef GTEST_HAS_TR1_TUPLE
3123d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// The user didn't tell us, so we need to figure it out.
3133d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
3143d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GCC provides <tr1/tuple> since 4.0.0.
3153d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
3163d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_TR1_TUPLE 1
3173d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else
3183d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_TR1_TUPLE 0
3193d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif  // __GNUC__
3203d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif  // GTEST_HAS_TR1_TUPLE
3213d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
3225145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// To avoid conditional compilation everywhere, we make it
3235145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// gtest-port.h's responsibility to #include the header implementing
3245145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple.
3255145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if GTEST_HAS_TR1_TUPLE
3265145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if defined(__GNUC__)
3275145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// GCC implements tr1/tuple in the <tr1/tuple> header.  This does not
3285145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// conform to the TR1 spec, which requires the header to be <tuple>.
3295145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#include <tr1/tuple>
3305145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#else
3315145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// If the compiler is not GCC, we assume the user is using a
3325145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// spec-conforming TR1 implementation.
3335145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#include <tuple>
3345145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif  // __GNUC__
3355145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif  // GTEST_HAS_TR1_TUPLE
3365145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian
33704f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Determines whether clone(2) is supported.
33804f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Usually it will only be available on Linux, excluding
33904f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Linux on the Itanium architecture.
34004f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Also see http://linux.die.net/man/2/clone.
34104f025dd5746fca83c6c32f1729b3449721dd60eshiqian#ifndef GTEST_HAS_CLONE
34204f025dd5746fca83c6c32f1729b3449721dd60eshiqian// The user didn't tell us, so we need to figure it out.
34304f025dd5746fca83c6c32f1729b3449721dd60eshiqian
34404f025dd5746fca83c6c32f1729b3449721dd60eshiqian#if defined(GTEST_OS_LINUX) && !defined(__ia64__)
34504f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 1
34604f025dd5746fca83c6c32f1729b3449721dd60eshiqian#else
34704f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 0
34804f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif  // defined(GTEST_OS_LINUX) && !defined(__ia64__)
34904f025dd5746fca83c6c32f1729b3449721dd60eshiqian
35004f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif  // GTEST_HAS_CLONE
35104f025dd5746fca83c6c32f1729b3449721dd60eshiqian
352d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines whether to support death tests.
35304f025dd5746fca83c6c32f1729b3449721dd60eshiqian#if GTEST_HAS_STD_STRING && GTEST_HAS_CLONE
354d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_DEATH_TEST
355d201456903f3ecae1f7794edfab0d5678e64226shiqian// On some platforms, <regex.h> needs someone to define size_t, and
356e4e9a8bd7d2dbbad62030c8f80513e3c81b32213shiqian// won't compile otherwise.  We can #include it here as we already
357e4e9a8bd7d2dbbad62030c8f80513e3c81b32213shiqian// included <stdlib.h>, which is guaranteed to define size_t through
358e4e9a8bd7d2dbbad62030c8f80513e3c81b32213shiqian// <stddef.h>.
359d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <regex.h>
360d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <vector>
361d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <fcntl.h>
362d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <sys/mman.h>
36304f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif  // GTEST_HAS_STD_STRING && GTEST_HAS_CLONE
364d201456903f3ecae1f7794edfab0d5678e64226shiqian
3653d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support value-parameterized tests.
3663d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
3673d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(__GNUC__) || (_MSC_VER >= 1400)
3683d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// TODO(vladl@google.com): get the implementation rid of vector and list
3693d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// to compile on MSVC 7.1.
3703d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_PARAM_TEST
3713d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)
3723d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
373a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Determines whether to support type-driven tests.
374a2b1a8556ea64014606d78b09333d9c522430a25shiqian
375a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Typed tests need <typeinfo> and variadic macros, which gcc and VC
376a2b1a8556ea64014606d78b09333d9c522430a25shiqian// 8.0+ support.
377a2b1a8556ea64014606d78b09333d9c522430a25shiqian#if defined(__GNUC__) || (_MSC_VER >= 1400)
378a2b1a8556ea64014606d78b09333d9c522430a25shiqian#define GTEST_HAS_TYPED_TEST
379a2b1a8556ea64014606d78b09333d9c522430a25shiqian#define GTEST_HAS_TYPED_TEST_P
380a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif  // defined(__GNUC__) || (_MSC_VER >= 1400)
381a2b1a8556ea64014606d78b09333d9c522430a25shiqian
3823d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support Combine(). This only makes sense when
3833d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// value-parameterized tests are enabled.
3843d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(GTEST_HAS_PARAM_TEST) && GTEST_HAS_TR1_TUPLE
3853d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_COMBINE
3863d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif  // defined(GTEST_HAS_PARAM_TEST) && GTEST_HAS_TR1_TUPLE
3873d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
3880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Determines whether the system compiler uses UTF-16 for encoding wide strings.
3890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_CYGWIN) || \
390e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian        defined(GTEST_OS_SYMBIAN)
3910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#define GTEST_WIDE_STRING_USES_UTF16_ 1
3920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#endif
3930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev
394d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines some utility macros.
395d201456903f3ecae1f7794edfab0d5678e64226shiqian
396d201456903f3ecae1f7794edfab0d5678e64226shiqian// The GNU compiler emits a warning if nested "if" statements are followed by
397d201456903f3ecae1f7794edfab0d5678e64226shiqian// an "else" statement and braces are not used to explicitly disambiguate the
398d201456903f3ecae1f7794edfab0d5678e64226shiqian// "else" binding.  This leads to problems with code like:
399d201456903f3ecae1f7794edfab0d5678e64226shiqian//
400d201456903f3ecae1f7794edfab0d5678e64226shiqian//   if (gate)
401d201456903f3ecae1f7794edfab0d5678e64226shiqian//     ASSERT_*(condition) << "Some message";
402d201456903f3ecae1f7794edfab0d5678e64226shiqian//
403d201456903f3ecae1f7794edfab0d5678e64226shiqian// The "switch (0) case 0:" idiom is used to suppress this.
404d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __INTEL_COMPILER
405e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
406d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
407e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0:  // NOLINT
408d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif
409d201456903f3ecae1f7794edfab0d5678e64226shiqian
410d201456903f3ecae1f7794edfab0d5678e64226shiqian// Use this annotation at the end of a struct / class definition to
411d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent the compiler from optimizing away instances that are never
412d201456903f3ecae1f7794edfab0d5678e64226shiqian// used.  This is useful when all interesting logic happens inside the
413d201456903f3ecae1f7794edfab0d5678e64226shiqian// c'tor and / or d'tor.  Example:
414d201456903f3ecae1f7794edfab0d5678e64226shiqian//
415d201456903f3ecae1f7794edfab0d5678e64226shiqian//   struct Foo {
416d201456903f3ecae1f7794edfab0d5678e64226shiqian//     Foo() { ... }
417e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   } GTEST_ATTRIBUTE_UNUSED_;
418bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#if defined(__GNUC__) && !defined(COMPILER_ICC)
419e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
420bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#else
421e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_
422bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#endif
423d201456903f3ecae1f7794edfab0d5678e64226shiqian
424d201456903f3ecae1f7794edfab0d5678e64226shiqian// A macro to disallow the evil copy constructor and operator= functions
425d201456903f3ecae1f7794edfab0d5678e64226shiqian// This should be used in the private: declarations for a class.
426e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
427d201456903f3ecae1f7794edfab0d5678e64226shiqian  type(const type &);\
428d201456903f3ecae1f7794edfab0d5678e64226shiqian  void operator=(const type &)
429d201456903f3ecae1f7794edfab0d5678e64226shiqian
430d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tell the compiler to warn about unused return values for functions declared
431d201456903f3ecae1f7794edfab0d5678e64226shiqian// with this macro.  The macro should be used on function declarations
432d201456903f3ecae1f7794edfab0d5678e64226shiqian// following the argument list:
433d201456903f3ecae1f7794edfab0d5678e64226shiqian//
434e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
43564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
436e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
437d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
438e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_
43964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
440d201456903f3ecae1f7794edfab0d5678e64226shiqian
441d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing {
442d201456903f3ecae1f7794edfab0d5678e64226shiqian
443d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message;
444d201456903f3ecae1f7794edfab0d5678e64226shiqian
445d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal {
446d201456903f3ecae1f7794edfab0d5678e64226shiqian
447d201456903f3ecae1f7794edfab0d5678e64226shiqianclass String;
448d201456903f3ecae1f7794edfab0d5678e64226shiqian
449d201456903f3ecae1f7794edfab0d5678e64226shiqian// std::strstream is deprecated.  However, we have to use it on
450d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows as std::stringstream won't compile on Windows when
451d201456903f3ecae1f7794edfab0d5678e64226shiqian// exceptions are disabled.  We use std::stringstream on other
452d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms to avoid compiler warnings there.
453d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING
454d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::stringstream StrStream;
455d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
456d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::strstream StrStream;
457d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING
458d201456903f3ecae1f7794edfab0d5678e64226shiqian
459d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines scoped_ptr.
460d201456903f3ecae1f7794edfab0d5678e64226shiqian
461d201456903f3ecae1f7794edfab0d5678e64226shiqian// This implementation of scoped_ptr is PARTIAL - it only contains
462d201456903f3ecae1f7794edfab0d5678e64226shiqian// enough stuff to satisfy Google Test's need.
463d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T>
464d201456903f3ecae1f7794edfab0d5678e64226shiqianclass scoped_ptr {
465d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
466d201456903f3ecae1f7794edfab0d5678e64226shiqian  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
467d201456903f3ecae1f7794edfab0d5678e64226shiqian  ~scoped_ptr() { reset(); }
468d201456903f3ecae1f7794edfab0d5678e64226shiqian
469d201456903f3ecae1f7794edfab0d5678e64226shiqian  T& operator*() const { return *ptr_; }
470d201456903f3ecae1f7794edfab0d5678e64226shiqian  T* operator->() const { return ptr_; }
471d201456903f3ecae1f7794edfab0d5678e64226shiqian  T* get() const { return ptr_; }
472d201456903f3ecae1f7794edfab0d5678e64226shiqian
473d201456903f3ecae1f7794edfab0d5678e64226shiqian  T* release() {
474d201456903f3ecae1f7794edfab0d5678e64226shiqian    T* const ptr = ptr_;
475d201456903f3ecae1f7794edfab0d5678e64226shiqian    ptr_ = NULL;
476d201456903f3ecae1f7794edfab0d5678e64226shiqian    return ptr;
477d201456903f3ecae1f7794edfab0d5678e64226shiqian  }
478d201456903f3ecae1f7794edfab0d5678e64226shiqian
479d201456903f3ecae1f7794edfab0d5678e64226shiqian  void reset(T* p = NULL) {
480d201456903f3ecae1f7794edfab0d5678e64226shiqian    if (p != ptr_) {
481d201456903f3ecae1f7794edfab0d5678e64226shiqian      if (sizeof(T) > 0) {  // Makes sure T is a complete type.
482d201456903f3ecae1f7794edfab0d5678e64226shiqian        delete ptr_;
483d201456903f3ecae1f7794edfab0d5678e64226shiqian      }
484d201456903f3ecae1f7794edfab0d5678e64226shiqian      ptr_ = p;
485d201456903f3ecae1f7794edfab0d5678e64226shiqian    }
486d201456903f3ecae1f7794edfab0d5678e64226shiqian  }
487d201456903f3ecae1f7794edfab0d5678e64226shiqian private:
488d201456903f3ecae1f7794edfab0d5678e64226shiqian  T* ptr_;
489d201456903f3ecae1f7794edfab0d5678e64226shiqian
490e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
491d201456903f3ecae1f7794edfab0d5678e64226shiqian};
492d201456903f3ecae1f7794edfab0d5678e64226shiqian
493d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_HAS_DEATH_TEST
494d201456903f3ecae1f7794edfab0d5678e64226shiqian
4953d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Defines RE.
496d201456903f3ecae1f7794edfab0d5678e64226shiqian
497d201456903f3ecae1f7794edfab0d5678e64226shiqian// A simple C++ wrapper for <regex.h>.  It uses the POSIX Enxtended
498d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular Expression syntax.
499d201456903f3ecae1f7794edfab0d5678e64226shiqianclass RE {
500d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
501d201456903f3ecae1f7794edfab0d5678e64226shiqian  // Constructs an RE from a string.
502d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING
503d201456903f3ecae1f7794edfab0d5678e64226shiqian  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
504d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING
505d201456903f3ecae1f7794edfab0d5678e64226shiqian
506d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING
507d201456903f3ecae1f7794edfab0d5678e64226shiqian  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
508d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_GLOBAL_STRING
509d201456903f3ecae1f7794edfab0d5678e64226shiqian
510d201456903f3ecae1f7794edfab0d5678e64226shiqian  RE(const char* regex) { Init(regex); }  // NOLINT
511d201456903f3ecae1f7794edfab0d5678e64226shiqian  ~RE();
512d201456903f3ecae1f7794edfab0d5678e64226shiqian
513d201456903f3ecae1f7794edfab0d5678e64226shiqian  // Returns the string representation of the regex.
514d201456903f3ecae1f7794edfab0d5678e64226shiqian  const char* pattern() const { return pattern_; }
515d201456903f3ecae1f7794edfab0d5678e64226shiqian
5163d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // FullMatch(str, re) returns true iff regular expression re matches
5173d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // the entire str.
5183d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // PartialMatch(str, re) returns true iff regular expression re
5193d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // matches a substring of str (including str itself).
5203d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  //
5213d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
5223d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  // when str contains NUL characters.
523d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING
5243d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  static bool FullMatch(const ::std::string& str, const RE& re) {
5253d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    return FullMatch(str.c_str(), re);
5263d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  }
527d201456903f3ecae1f7794edfab0d5678e64226shiqian  static bool PartialMatch(const ::std::string& str, const RE& re) {
528d201456903f3ecae1f7794edfab0d5678e64226shiqian    return PartialMatch(str.c_str(), re);
529d201456903f3ecae1f7794edfab0d5678e64226shiqian  }
530d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_STD_STRING
531d201456903f3ecae1f7794edfab0d5678e64226shiqian
532d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING
5333d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  static bool FullMatch(const ::string& str, const RE& re) {
5343d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    return FullMatch(str.c_str(), re);
5353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  }
536d201456903f3ecae1f7794edfab0d5678e64226shiqian  static bool PartialMatch(const ::string& str, const RE& re) {
537d201456903f3ecae1f7794edfab0d5678e64226shiqian    return PartialMatch(str.c_str(), re);
538d201456903f3ecae1f7794edfab0d5678e64226shiqian  }
539d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_GLOBAL_STRING
540d201456903f3ecae1f7794edfab0d5678e64226shiqian
5413d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  static bool FullMatch(const char* str, const RE& re);
542d201456903f3ecae1f7794edfab0d5678e64226shiqian  static bool PartialMatch(const char* str, const RE& re);
543d201456903f3ecae1f7794edfab0d5678e64226shiqian
544d201456903f3ecae1f7794edfab0d5678e64226shiqian private:
545d201456903f3ecae1f7794edfab0d5678e64226shiqian  void Init(const char* regex);
546d201456903f3ecae1f7794edfab0d5678e64226shiqian
547d201456903f3ecae1f7794edfab0d5678e64226shiqian  // We use a const char* instead of a string, as Google Test may be used
548d201456903f3ecae1f7794edfab0d5678e64226shiqian  // where string is not available.  We also do not use Google Test's own
549d201456903f3ecae1f7794edfab0d5678e64226shiqian  // String type here, in order to simplify dependencies between the
550d201456903f3ecae1f7794edfab0d5678e64226shiqian  // files.
551d201456903f3ecae1f7794edfab0d5678e64226shiqian  const char* pattern_;
5523d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  regex_t full_regex_;     // For FullMatch().
5533d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  regex_t partial_regex_;  // For PartialMatch().
554d201456903f3ecae1f7794edfab0d5678e64226shiqian  bool is_valid_;
555d201456903f3ecae1f7794edfab0d5678e64226shiqian};
556d201456903f3ecae1f7794edfab0d5678e64226shiqian
557d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_DEATH_TEST
558d201456903f3ecae1f7794edfab0d5678e64226shiqian
559d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines logging utilities:
560e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian//   GTEST_LOG_()   - logs messages at the specified severity level.
561d201456903f3ecae1f7794edfab0d5678e64226shiqian//   LogToStderr()  - directs all log messages to stderr.
562d201456903f3ecae1f7794edfab0d5678e64226shiqian//   FlushInfoLog() - flushes informational log messages.
563d201456903f3ecae1f7794edfab0d5678e64226shiqian
564d201456903f3ecae1f7794edfab0d5678e64226shiqianenum GTestLogSeverity {
565d201456903f3ecae1f7794edfab0d5678e64226shiqian  GTEST_INFO,
566d201456903f3ecae1f7794edfab0d5678e64226shiqian  GTEST_WARNING,
567d201456903f3ecae1f7794edfab0d5678e64226shiqian  GTEST_ERROR,
568d201456903f3ecae1f7794edfab0d5678e64226shiqian  GTEST_FATAL
569d201456903f3ecae1f7794edfab0d5678e64226shiqian};
570d201456903f3ecae1f7794edfab0d5678e64226shiqian
571d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid GTestLog(GTestLogSeverity severity, const char* file,
572d201456903f3ecae1f7794edfab0d5678e64226shiqian              int line, const char* msg);
573d201456903f3ecae1f7794edfab0d5678e64226shiqian
574e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_LOG_(severity, msg)\
575d201456903f3ecae1f7794edfab0d5678e64226shiqian    ::testing::internal::GTestLog(\
576d201456903f3ecae1f7794edfab0d5678e64226shiqian        ::testing::internal::GTEST_##severity, __FILE__, __LINE__, \
577d201456903f3ecae1f7794edfab0d5678e64226shiqian        (::testing::Message() << (msg)).GetString().c_str())
578d201456903f3ecae1f7794edfab0d5678e64226shiqian
579d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void LogToStderr() {}
580d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void FlushInfoLog() { fflush(NULL); }
581d201456903f3ecae1f7794edfab0d5678e64226shiqian
582d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines the stderr capturer:
583d201456903f3ecae1f7794edfab0d5678e64226shiqian//   CaptureStderr     - starts capturing stderr.
584d201456903f3ecae1f7794edfab0d5678e64226shiqian//   GetCapturedStderr - stops capturing stderr and returns the captured string.
585d201456903f3ecae1f7794edfab0d5678e64226shiqian
586d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_HAS_DEATH_TEST
587d201456903f3ecae1f7794edfab0d5678e64226shiqian
588d201456903f3ecae1f7794edfab0d5678e64226shiqian// A copy of all command line arguments.  Set by InitGoogleTest().
589d201456903f3ecae1f7794edfab0d5678e64226shiqianextern ::std::vector<String> g_argvs;
590d201456903f3ecae1f7794edfab0d5678e64226shiqian
591d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid CaptureStderr();
592d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_DEATH_TEST implies we have ::std::string.
593d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::string GetCapturedStderr();
594d201456903f3ecae1f7794edfab0d5678e64226shiqianconst ::std::vector<String>& GetArgvs();
595d201456903f3ecae1f7794edfab0d5678e64226shiqian
596d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_HAS_DEATH_TEST
597d201456903f3ecae1f7794edfab0d5678e64226shiqian
598d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines synchronization primitives.
599d201456903f3ecae1f7794edfab0d5678e64226shiqian
600d201456903f3ecae1f7794edfab0d5678e64226shiqian// A dummy implementation of synchronization primitives (mutex, lock,
601d201456903f3ecae1f7794edfab0d5678e64226shiqian// and thread-local variable).  Necessary for compiling Google Test where
602d201456903f3ecae1f7794edfab0d5678e64226shiqian// mutex is not supported - using Google Test in multiple threads is not
603d201456903f3ecae1f7794edfab0d5678e64226shiqian// supported on such platforms.
604d201456903f3ecae1f7794edfab0d5678e64226shiqian
605d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Mutex {
606d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
607d201456903f3ecae1f7794edfab0d5678e64226shiqian  Mutex() {}
608b75872639683cf572253f20863982324b113205eshiqian  explicit Mutex(int /*unused*/) {}
609d201456903f3ecae1f7794edfab0d5678e64226shiqian  void AssertHeld() const {}
610d201456903f3ecae1f7794edfab0d5678e64226shiqian  enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 };
611d201456903f3ecae1f7794edfab0d5678e64226shiqian};
612d201456903f3ecae1f7794edfab0d5678e64226shiqian
613d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot call it MutexLock directly as the ctor declaration would
614d201456903f3ecae1f7794edfab0d5678e64226shiqian// conflict with a macro named MutexLock, which is defined on some
615d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms.  Hence the typedef trick below.
616d201456903f3ecae1f7794edfab0d5678e64226shiqianclass GTestMutexLock {
617d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
618d201456903f3ecae1f7794edfab0d5678e64226shiqian  explicit GTestMutexLock(Mutex*) {}  // NOLINT
619d201456903f3ecae1f7794edfab0d5678e64226shiqian};
620d201456903f3ecae1f7794edfab0d5678e64226shiqian
621d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef GTestMutexLock MutexLock;
622d201456903f3ecae1f7794edfab0d5678e64226shiqian
623d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T>
624d201456903f3ecae1f7794edfab0d5678e64226shiqianclass ThreadLocal {
625d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
626e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian  ThreadLocal() : value_() {}
627e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian  explicit ThreadLocal(const T& value) : value_(value) {}
628d201456903f3ecae1f7794edfab0d5678e64226shiqian  T* pointer() { return &value_; }
629d201456903f3ecae1f7794edfab0d5678e64226shiqian  const T* pointer() const { return &value_; }
630d201456903f3ecae1f7794edfab0d5678e64226shiqian  const T& get() const { return value_; }
631d201456903f3ecae1f7794edfab0d5678e64226shiqian  void set(const T& value) { value_ = value; }
632d201456903f3ecae1f7794edfab0d5678e64226shiqian private:
633d201456903f3ecae1f7794edfab0d5678e64226shiqian  T value_;
634d201456903f3ecae1f7794edfab0d5678e64226shiqian};
635d201456903f3ecae1f7794edfab0d5678e64226shiqian
636d201456903f3ecae1f7794edfab0d5678e64226shiqian// There's no portable way to detect the number of threads, so we just
637d201456903f3ecae1f7794edfab0d5678e64226shiqian// return 0 to indicate that we cannot detect it.
638d201456903f3ecae1f7794edfab0d5678e64226shiqianinline size_t GetThreadCount() { return 0; }
639d201456903f3ecae1f7794edfab0d5678e64226shiqian
640e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The above synchronization primitives have dummy implementations.
641e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Therefore Google Test is not thread-safe.
642e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_IS_THREADSAFE 0
643e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian
644d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
645d2849f573052ba8431a887e0034b1be353a0d9b4shiqian
646d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Passing non-POD classes through ellipsis (...) crashes the ARM
647d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// compiler.  The Nokia Symbian and the IBM XL C/C++ compiler try to
648d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// instantiate a copy constructor for objects passed through ellipsis
649d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// (...), failing for uncopyable objects.  We define this to indicate
650d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// the fact.
651d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_ELLIPSIS_NEEDS_COPY_ 1
652d201456903f3ecae1f7794edfab0d5678e64226shiqian
653d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
654d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// const T& and const T* in a function template.  These compilers
655d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// _can_ decide between class template specializations for T and T*,
656d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// so a tr1::type_traits-like is_pointer works.
657d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_NEEDS_IS_POINTER_ 1
658d201456903f3ecae1f7794edfab0d5678e64226shiqian
659d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#endif  // defined(__SYMBIAN32__) || defined(__IBMCPP__)
660d201456903f3ecae1f7794edfab0d5678e64226shiqian
661d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value>
662d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct bool_constant {
663d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef bool_constant<bool_value> type;
664d201456903f3ecae1f7794edfab0d5678e64226shiqian  static const bool value = bool_value;
665d201456903f3ecae1f7794edfab0d5678e64226shiqian};
666d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> const bool bool_constant<bool_value>::value;
667d201456903f3ecae1f7794edfab0d5678e64226shiqian
668d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<false> false_type;
669d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<true> true_type;
670d201456903f3ecae1f7794edfab0d5678e64226shiqian
671d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T>
672d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer : public false_type {};
673d201456903f3ecae1f7794edfab0d5678e64226shiqian
674d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T>
675d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer<T*> : public true_type {};
676d201456903f3ecae1f7794edfab0d5678e64226shiqian
677d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines BiggestInt as the biggest signed integer type the compiler
678d201456903f3ecae1f7794edfab0d5678e64226shiqian// supports.
679d201456903f3ecae1f7794edfab0d5678e64226shiqian
680d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS
681d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef __int64 BiggestInt;
682d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
683d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef long long BiggestInt;  // NOLINT
684d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_OS_WINDOWS
685d201456903f3ecae1f7794edfab0d5678e64226shiqian
686d201456903f3ecae1f7794edfab0d5678e64226shiqian// The maximum number a BiggestInt can represent.  This definition
687d201456903f3ecae1f7794edfab0d5678e64226shiqian// works no matter BiggestInt is represented in one's complement or
688d201456903f3ecae1f7794edfab0d5678e64226shiqian// two's complement.
689d201456903f3ecae1f7794edfab0d5678e64226shiqian//
690d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot rely on numeric_limits in STL, as __int64 and long long
691d201456903f3ecae1f7794edfab0d5678e64226shiqian// are not part of standard C++ and numeric_limits doesn't need to be
692d201456903f3ecae1f7794edfab0d5678e64226shiqian// defined for them.
693d201456903f3ecae1f7794edfab0d5678e64226shiqianconst BiggestInt kMaxBiggestInt =
694d201456903f3ecae1f7794edfab0d5678e64226shiqian    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
695d201456903f3ecae1f7794edfab0d5678e64226shiqian
696d201456903f3ecae1f7794edfab0d5678e64226shiqian// This template class serves as a compile-time function from size to
697d201456903f3ecae1f7794edfab0d5678e64226shiqian// type.  It maps a size in bytes to a primitive type with that
698d201456903f3ecae1f7794edfab0d5678e64226shiqian// size. e.g.
699d201456903f3ecae1f7794edfab0d5678e64226shiqian//
700d201456903f3ecae1f7794edfab0d5678e64226shiqian//   TypeWithSize<4>::UInt
701d201456903f3ecae1f7794edfab0d5678e64226shiqian//
702d201456903f3ecae1f7794edfab0d5678e64226shiqian// is typedef-ed to be unsigned int (unsigned integer made up of 4
703d201456903f3ecae1f7794edfab0d5678e64226shiqian// bytes).
704d201456903f3ecae1f7794edfab0d5678e64226shiqian//
705d201456903f3ecae1f7794edfab0d5678e64226shiqian// Such functionality should belong to STL, but I cannot find it
706d201456903f3ecae1f7794edfab0d5678e64226shiqian// there.
707d201456903f3ecae1f7794edfab0d5678e64226shiqian//
708d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test uses this class in the implementation of floating-point
709d201456903f3ecae1f7794edfab0d5678e64226shiqian// comparison.
710d201456903f3ecae1f7794edfab0d5678e64226shiqian//
711d201456903f3ecae1f7794edfab0d5678e64226shiqian// For now it only handles UInt (unsigned int) as that's all Google Test
712d201456903f3ecae1f7794edfab0d5678e64226shiqian// needs.  Other types can be easily added in the future if need
713d201456903f3ecae1f7794edfab0d5678e64226shiqian// arises.
714d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <size_t size>
715d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize {
716d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
717d201456903f3ecae1f7794edfab0d5678e64226shiqian  // This prevents the user from using TypeWithSize<N> with incorrect
718d201456903f3ecae1f7794edfab0d5678e64226shiqian  // values of N.
719d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef void UInt;
720d201456903f3ecae1f7794edfab0d5678e64226shiqian};
721d201456903f3ecae1f7794edfab0d5678e64226shiqian
722d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 4.
723d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <>
724d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<4> {
725d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
726d201456903f3ecae1f7794edfab0d5678e64226shiqian  // unsigned int has size 4 in both gcc and MSVC.
727d201456903f3ecae1f7794edfab0d5678e64226shiqian  //
728d201456903f3ecae1f7794edfab0d5678e64226shiqian  // As base/basictypes.h doesn't compile on Windows, we cannot use
729d201456903f3ecae1f7794edfab0d5678e64226shiqian  // uint32, uint64, and etc here.
730d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef int Int;
731d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef unsigned int UInt;
732d201456903f3ecae1f7794edfab0d5678e64226shiqian};
733d201456903f3ecae1f7794edfab0d5678e64226shiqian
734d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 8.
735d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <>
736d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<8> {
737d201456903f3ecae1f7794edfab0d5678e64226shiqian public:
738d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS
739d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef __int64 Int;
740d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef unsigned __int64 UInt;
741d201456903f3ecae1f7794edfab0d5678e64226shiqian#else
742d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef long long Int;  // NOLINT
743d201456903f3ecae1f7794edfab0d5678e64226shiqian  typedef unsigned long long UInt;  // NOLINT
744d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_OS_WINDOWS
745d201456903f3ecae1f7794edfab0d5678e64226shiqian};
746d201456903f3ecae1f7794edfab0d5678e64226shiqian
747d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types of known sizes.
748d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::Int Int32;
749d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::UInt UInt32;
750d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int Int64;
751d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::UInt UInt64;
752d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
753d201456903f3ecae1f7794edfab0d5678e64226shiqian
754d201456903f3ecae1f7794edfab0d5678e64226shiqian// Utilities for command line flags and environment variables.
755d201456903f3ecae1f7794edfab0d5678e64226shiqian
756d201456903f3ecae1f7794edfab0d5678e64226shiqian// A wrapper for getenv() that works on Linux, Windows, and Mac OS.
757d201456903f3ecae1f7794edfab0d5678e64226shiqianinline const char* GetEnv(const char* name) {
758d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef _WIN32_WCE  // We are on Windows CE.
759d201456903f3ecae1f7794edfab0d5678e64226shiqian  // CE has no environment variables.
760d201456903f3ecae1f7794edfab0d5678e64226shiqian  return NULL;
761d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined(GTEST_OS_WINDOWS)  // We are on Windows proper.
762d201456903f3ecae1f7794edfab0d5678e64226shiqian  // MSVC 8 deprecates getenv(), so we want to suppress warning 4996
763d201456903f3ecae1f7794edfab0d5678e64226shiqian  // (deprecated function) there.
764d201456903f3ecae1f7794edfab0d5678e64226shiqian#pragma warning(push)          // Saves the current warning state.
765d201456903f3ecae1f7794edfab0d5678e64226shiqian#pragma warning(disable:4996)  // Temporarily disables warning 4996.
766d201456903f3ecae1f7794edfab0d5678e64226shiqian  return getenv(name);
767d201456903f3ecae1f7794edfab0d5678e64226shiqian#pragma warning(pop)           // Restores the warning state.
768d201456903f3ecae1f7794edfab0d5678e64226shiqian#else  // We are on Linux or Mac OS.
769d201456903f3ecae1f7794edfab0d5678e64226shiqian  return getenv(name);
770d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif
771d201456903f3ecae1f7794edfab0d5678e64226shiqian}
772d201456903f3ecae1f7794edfab0d5678e64226shiqian
773bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#ifdef _WIN32_WCE
774bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian// Windows CE has no C library. The abort() function is used in
775bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian// several places in Google Test. This implementation provides a reasonable
776bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian// imitation of standard behaviour.
777bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianvoid abort();
778bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#else
779bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianinline void abort() { ::abort(); }
780bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#endif  // _WIN32_WCE
781bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian
7823d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// INTERNAL IMPLEMENTATION - DO NOT USE.
7833d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//
7843d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
7853d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// is not satisfied.
7863d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//  Synopsys:
7873d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    GTEST_CHECK_(boolean_condition);
7883d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//     or
7893d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    GTEST_CHECK_(boolean_condition) << "Additional message";
7903d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//
7913d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    This checks the condition and if the condition is not satisfied
7923d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    it prints message about the condition violation, including the
7933d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    condition itself, plus additional message streamed into it, if any,
7943d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    and then it aborts the program. It aborts the program irrespective of
7953d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev//    whether it is built in the debug mode or not.
7963d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevclass GTestCheckProvider {
7973d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev public:
7983d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  GTestCheckProvider(const char* condition, const char* file, int line) {
7993d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    FormatFileLocation(file, line);
8003d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    ::std::cerr << " ERROR: Condition " << condition << " failed. ";
8013d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  }
8023d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  ~GTestCheckProvider() {
8033d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    ::std::cerr << ::std::endl;
8043d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    abort();
8053d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  }
8063d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  void FormatFileLocation(const char* file, int line) {
8073d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    if (file == NULL)
8083d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      file = "unknown file";
8093d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    if (line < 0) {
8103d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      ::std::cerr << file << ":";
8113d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    } else {
8123d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if _MSC_VER
8133d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      ::std::cerr << file << "(" << line << "):";
8143d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else
8153d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      ::std::cerr << file << ":" << line << ":";
8163d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif
8173d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    }
8183d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  }
8193d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev  ::std::ostream& GetStream() { return ::std::cerr; }
8203d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev};
8213d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_CHECK_(condition) \
8223d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
8233d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    if (condition) \
8243d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      ; \
8253d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev    else \
8263d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev      ::testing::internal::GTestCheckProvider(\
8273d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev          #condition, __FILE__, __LINE__).GetStream()
8283d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev
829d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macro for referencing flags.
830d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG(name) FLAGS_gtest_##name
831d201456903f3ecae1f7794edfab0d5678e64226shiqian
832d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for declaring flags.
833e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name)
834e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_int32_(name) \
835d201456903f3ecae1f7794edfab0d5678e64226shiqian    extern ::testing::internal::Int32 GTEST_FLAG(name)
836e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_string_(name) \
837d201456903f3ecae1f7794edfab0d5678e64226shiqian    extern ::testing::internal::String GTEST_FLAG(name)
838d201456903f3ecae1f7794edfab0d5678e64226shiqian
839d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for defining flags.
840e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_bool_(name, default_val, doc) \
841d201456903f3ecae1f7794edfab0d5678e64226shiqian    bool GTEST_FLAG(name) = (default_val)
842e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_int32_(name, default_val, doc) \
843d201456903f3ecae1f7794edfab0d5678e64226shiqian    ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
844e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_string_(name, default_val, doc) \
845d201456903f3ecae1f7794edfab0d5678e64226shiqian    ::testing::internal::String GTEST_FLAG(name) = (default_val)
846d201456903f3ecae1f7794edfab0d5678e64226shiqian
847d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
848d201456903f3ecae1f7794edfab0d5678e64226shiqian// to *value and returns true; otherwise leaves *value unchanged and returns
849d201456903f3ecae1f7794edfab0d5678e64226shiqian// false.
850d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(chandlerc): Find a better way to refactor flag and environment parsing
851d201456903f3ecae1f7794edfab0d5678e64226shiqian// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
852d201456903f3ecae1f7794edfab0d5678e64226shiqian// function.
853d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32(const Message& src_text, const char* str, Int32* value);
854d201456903f3ecae1f7794edfab0d5678e64226shiqian
855d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses a bool/Int32/string from the environment variable
856d201456903f3ecae1f7794edfab0d5678e64226shiqian// corresponding to the given Google Test flag.
857d201456903f3ecae1f7794edfab0d5678e64226shiqianbool BoolFromGTestEnv(const char* flag, bool default_val);
858d201456903f3ecae1f7794edfab0d5678e64226shiqianInt32 Int32FromGTestEnv(const char* flag, Int32 default_val);
859d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* StringFromGTestEnv(const char* flag, const char* default_val);
860d201456903f3ecae1f7794edfab0d5678e64226shiqian
861d201456903f3ecae1f7794edfab0d5678e64226shiqian}  // namespace internal
862d201456903f3ecae1f7794edfab0d5678e64226shiqian}  // namespace testing
863d201456903f3ecae1f7794edfab0d5678e64226shiqian
864d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
865