gtest-port.h revision 3569c3c86d520bd04ea806f84c9cb5aad0615fdf
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. 45cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions 46cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// are enabled. 47d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 48d201456903f3ecae1f7794edfab0d5678e64226shiqian// is/isn't available (some systems define 49d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::string, which is different to std::string). 50d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 51d201456903f3ecae1f7794edfab0d5678e64226shiqian// is/isn't available (some systems define 52d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::wstring, which is different to std::wstring). 53e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 54e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// is/isn't available. 5504f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 5604f025dd5746fca83c6c32f1729b3449721dd60eshiqian// enabled. 5704f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 5804f025dd5746fca83c6c32f1729b3449721dd60eshiqian// std::wstring does/doesn't work (Google Test can 5904f025dd5746fca83c6c32f1729b3449721dd60eshiqian// be used where std::wstring is unavailable). 60532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// is/isn't available. 62f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 63f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// compiler supports Microsoft's "Structured 64f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Exception Handling". 65532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 66532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// Test's own tr1 tuple implementation should be 67532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// used. Unused when the user sets 68532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// GTEST_HAS_TR1_TUPLE to 0. 6983589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// GTEST_LINKED_AS_SHARED_LIBRARY 7083589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// - Define to 1 when compiling tests that use 7183589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// Google Test as a shared library (known as 7283589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// DLL on Windows). 7383589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// GTEST_CREATE_SHARED_LIBRARY 7483589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// - Define to 1 when compiling Google Test itself 7583589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan// as a shared library. 76d201456903f3ecae1f7794edfab0d5678e64226shiqian 77d201456903f3ecae1f7794edfab0d5678e64226shiqian// This header defines the following utilities: 78d201456903f3ecae1f7794edfab0d5678e64226shiqian// 790af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating the current platform (defined to 1 if compiled on 800af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the given platform; otherwise undefined): 8106d04c0945bf47bae90532552e6e8294802fc9aavladlosev// GTEST_OS_AIX - IBM AIX 820af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_CYGWIN - Cygwin 830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_LINUX - Linux 840af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_MAC - Mac OS X 850af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SOLARIS - Sun Solaris 860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SYMBIAN - Symbian 87b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 88b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 89b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS_MINGW - MinGW 9081e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_ZOS - z/OS 92d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// 93b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 94b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// most stable support. Since core members of the Google Test project 95b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// don't have access to other platforms, support for them may be less 96b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// stable. If you notice any problems on your platform, please notify 97b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// googletestframework@googlegroups.com (patches for fixing them are 98b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// even more welcome!). 99b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// 1000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Note that it is possible that none of the GTEST_OS_* macros are defined. 101d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1020af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating available Google Test features (defined to 1 if 1030af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the corresponding feature is supported; otherwise undefined): 1040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 1050af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// tests) 1060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_DEATH_TEST - death tests 1070af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_PARAM_TEST - value-parameterized tests 1080af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST - typed tests 1090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 1100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 1110af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_SIMPLE_RE - our own simple regex is used; 112c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// the above two are mutually exclusive. 11306d04c0945bf47bae90532552e6e8294802fc9aavladlosev// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). 114d201456903f3ecae1f7794edfab0d5678e64226shiqian// 115d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for basic C++ coding: 116e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 1170da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 1180da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// variable don't have to be used. 1197b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// GTEST_DISALLOW_ASSIGN_ - disables operator=. 120e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 121e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 122d201456903f3ecae1f7794edfab0d5678e64226shiqian// 123d201456903f3ecae1f7794edfab0d5678e64226shiqian// Synchronization: 124d201456903f3ecae1f7794edfab0d5678e64226shiqian// Mutex, MutexLock, ThreadLocal, GetThreadCount() 125d201456903f3ecae1f7794edfab0d5678e64226shiqian// - synchronization primitives. 126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 127e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// synchronization primitives have real implementations 128e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// and Google Test is thread-safe; or 0 otherwise. 129d201456903f3ecae1f7794edfab0d5678e64226shiqian// 130d201456903f3ecae1f7794edfab0d5678e64226shiqian// Template meta programming: 131d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 132d201456903f3ecae1f7794edfab0d5678e64226shiqian// 133d201456903f3ecae1f7794edfab0d5678e64226shiqian// Smart pointers: 134d201456903f3ecae1f7794edfab0d5678e64226shiqian// scoped_ptr - as in TR2. 135d201456903f3ecae1f7794edfab0d5678e64226shiqian// 136d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular expressions: 137d201456903f3ecae1f7794edfab0d5678e64226shiqian// RE - a simple regular expression class using the POSIX 138d201456903f3ecae1f7794edfab0d5678e64226shiqian// Extended Regular Expression syntax. Not available on 139d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows. 140d201456903f3ecae1f7794edfab0d5678e64226shiqian// 141d201456903f3ecae1f7794edfab0d5678e64226shiqian// Logging: 142e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_LOG_() - logs messages at the specified severity level. 143d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 144d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 145d201456903f3ecae1f7794edfab0d5678e64226shiqian// 146fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// Stdout and stderr capturing: 147fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// CaptureStdout() - starts capturing stdout. 148fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// GetCapturedStdout() - stops capturing stdout and returns the captured 149fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// string. 150d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr() - starts capturing stderr. 151d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr() - stops capturing stderr and returns the captured 152d201456903f3ecae1f7794edfab0d5678e64226shiqian// string. 153d201456903f3ecae1f7794edfab0d5678e64226shiqian// 154d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types: 155d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize - maps an integer to a int type. 156d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32, UInt32, Int64, UInt64, TimeInMillis 157d201456903f3ecae1f7794edfab0d5678e64226shiqian// - integers of known sizes. 158d201456903f3ecae1f7794edfab0d5678e64226shiqian// BiggestInt - the biggest signed integer type. 159d201456903f3ecae1f7794edfab0d5678e64226shiqian// 160d201456903f3ecae1f7794edfab0d5678e64226shiqian// Command-line utilities: 161d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_FLAG() - references a flag. 162d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DECLARE_*() - declares a flag. 163d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DEFINE_*() - defines a flag. 164d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetArgvs() - returns the command line as a vector of strings. 165d201456903f3ecae1f7794edfab0d5678e64226shiqian// 166d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variable utilities: 167d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetEnv() - gets the value of an environment variable. 168d201456903f3ecae1f7794edfab0d5678e64226shiqian// BoolFromGTestEnv() - parses a bool environment variable. 169d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32FromGTestEnv() - parses an Int32 environment variable. 170d201456903f3ecae1f7794edfab0d5678e64226shiqian// StringFromGTestEnv() - parses a string environment variable. 171d201456903f3ecae1f7794edfab0d5678e64226shiqian 1724853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#include <stddef.h> // For ptrdiff_t 173d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 174d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdio.h> 1753c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <string.h> 1764853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1773c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/stat.h> 1784853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif // !_WIN32_WCE 1793c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1803c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <iostream> // NOLINT 1817b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#include <sstream> // NOLINT 1827b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#include <string> // NOLINT 183d201456903f3ecae1f7794edfab0d5678e64226shiqian 18487d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 1850af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_ "gtest_" 1866bfc4b2bd378940fa006bd32b9667ad4137d8f15vladlosev#define GTEST_FLAG_PREFIX_DASH_ "gtest-" 1870af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 18887d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_NAME_ "Google Test" 18987d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 190d201456903f3ecae1f7794edfab0d5678e64226shiqian 19164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines the version of gcc that is used to compile this. 19264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GNUC__ 19364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// 40302 means version 4.3.2. 19464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_GCC_VER_ \ 19564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 19664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ 19764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 198d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines the platform on which Google Test is compiled. 199e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#ifdef __CYGWIN__ 2000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_CYGWIN 1 201ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan#elif defined __SYMBIAN32__ 2020af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SYMBIAN 1 2036a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#elif defined _WIN32 2040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_WINDOWS 1 205b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#ifdef _WIN32_WCE 206b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_MOBILE 1 207b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#elif defined(__MINGW__) || defined(__MINGW32__) 208b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_MINGW 1 209b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 210b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_DESKTOP 1 211b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // _WIN32_WCE 212d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __APPLE__ 2130af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_MAC 1 214d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __linux__ 2150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_LINUX 1 216d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined __MVS__ 2170af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_ZOS 1 218d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined(__sun) && defined(__SVR4) 2190af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SOLARIS 1 22006d04c0945bf47bae90532552e6e8294802fc9aavladlosev#elif defined(_AIX) 22106d04c0945bf47bae90532552e6e8294802fc9aavladlosev#define GTEST_OS_AIX 1 2226a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#endif // __CYGWIN__ 223d201456903f3ecae1f7794edfab0d5678e64226shiqian 2245502540a5b5c5378824cd46591c2366bcf027555chandlerc#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \ 22506d04c0945bf47bae90532552e6e8294802fc9aavladlosev GTEST_OS_SOLARIS || GTEST_OS_AIX 226c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 227c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// On some platforms, <regex.h> needs someone to define size_t, and 228c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// won't compile otherwise. We can #include it here as we already 229c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// included <stdlib.h>, which is guaranteed to define size_t through 230c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// <stddef.h>. 231c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#include <regex.h> // NOLINT 2323c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <strings.h> // NOLINT 2333c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/types.h> // NOLINT 234c85a77a6ab0ef05c4a9a8554bf8c5e1c8687cc75zhanyong.wan#include <time.h> // NOLINT 2353c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <unistd.h> // NOLINT 2363c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 237c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_POSIX_RE 1 238c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2393c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#elif GTEST_OS_WINDOWS 2403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 241b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 2423c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <direct.h> // NOLINT 2433c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <io.h> // NOLINT 244b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif 2453c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 2463c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// <regex.h> is not available on Windows. Use our own simple regex 2473c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// implementation instead. 2483c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 2493c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 250c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else 251c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2524984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// <regex.h> may not be available on this platform. Use our own 2534984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// simple regex implementation instead. 254c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 255c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2565502540a5b5c5378824cd46591c2366bcf027555chandlerc#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || 25706d04c0945bf47bae90532552e6e8294802fc9aavladlosev // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS || GTEST_OS_AIX 258c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 259cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#ifndef GTEST_HAS_EXCEPTIONS 260cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// The user didn't tell us whether exceptions are enabled, so we need 261cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// to figure it out. 262c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 263c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 264c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// macro to enable exceptions, so we'll do the same. 265d201456903f3ecae1f7794edfab0d5678e64226shiqian// Assumes that exceptions are enabled by default. 266c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef _HAS_EXCEPTIONS 267d201456903f3ecae1f7794edfab0d5678e64226shiqian#define _HAS_EXCEPTIONS 1 268d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // _HAS_EXCEPTIONS 269d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 270cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__GNUC__) && __EXCEPTIONS 271cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 272cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#define GTEST_HAS_EXCEPTIONS 1 273cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__SUNPRO_CC) 274cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Sun Pro CC supports exceptions. However, there is no compile-time way of 275cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// detecting whether they are enabled or not. Therefore, we assume that 276cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// they are enabled unless the user tells us otherwise. 2773c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 1 27806d04c0945bf47bae90532552e6e8294802fc9aavladlosev#elif defined(__IBMCPP__) && __EXCEPTIONS 27906d04c0945bf47bae90532552e6e8294802fc9aavladlosev// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. 28006d04c0945bf47bae90532552e6e8294802fc9aavladlosev#define GTEST_HAS_EXCEPTIONS 1 2813c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#else 282cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// For other compilers, we assume exceptions are disabled to be 283cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// conservative. 2843c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 0 285c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // defined(_MSC_VER) || defined(__BORLANDC__) 286cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif // GTEST_HAS_EXCEPTIONS 287d201456903f3ecae1f7794edfab0d5678e64226shiqian 28888e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#if !defined(GTEST_HAS_STD_STRING) 28988e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// Even though we don't use this macro any longer, we keep it in case 29088e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// some clients still depend on it. 2913c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_STD_STRING 1 29288e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#elif !GTEST_HAS_STD_STRING 29388e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// The user told us that ::std::string isn't available. 29488e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#error "Google Test cannot be used where ::std::string isn't available." 29588e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#endif // !defined(GTEST_HAS_STD_STRING) 296d201456903f3ecae1f7794edfab0d5678e64226shiqian 297d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_STRING 298d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::string is available, so we need 299d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 300d201456903f3ecae1f7794edfab0d5678e64226shiqian 301d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_GLOBAL_STRING 0 302d201456903f3ecae1f7794edfab0d5678e64226shiqian 303d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 304d201456903f3ecae1f7794edfab0d5678e64226shiqian 305d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_STD_WSTRING 306d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::std::wstring is available, so we need 307d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 308d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 309d201456903f3ecae1f7794edfab0d5678e64226shiqian// is available. 310d201456903f3ecae1f7794edfab0d5678e64226shiqian 311bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.5 and below doesn't support ::std::wstring. 312bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.7 might add wstring support; this should be updated when clear. 313d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Solaris' libc++ doesn't support it either. 31488e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 315d201456903f3ecae1f7794edfab0d5678e64226shiqian 316d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 317d201456903f3ecae1f7794edfab0d5678e64226shiqian 318d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_WSTRING 319d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::wstring is available, so we need 320d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 321bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan#define GTEST_HAS_GLOBAL_WSTRING \ 322bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 323d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 324d201456903f3ecae1f7794edfab0d5678e64226shiqian 32564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines whether RTTI is available. 32664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifndef GTEST_HAS_RTTI 32764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// The user didn't tell us whether RTTI is enabled, so we need to 32864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// figure it out. 32964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _MSC_VER 33164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 33364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 33464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 33564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 3362346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#endif 33764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 3393569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 3403569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan 34164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GXX_RTTI 34264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 34364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 34464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 34564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GXX_RTTI 34664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 3473569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if 3483569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan// both the typeid and dynamic_cast features are present. 3493569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 3502346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan 3512346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#ifdef __RTTI_ALL__ 3522346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#define GTEST_HAS_RTTI 1 3532346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#else 3542346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#define GTEST_HAS_RTTI 0 3552346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan#endif 3562346d25784279f0eb6dfcd4e9ab28ae572baea07zhanyong.wan 35764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 35864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 3593569c3c86d520bd04ea806f84c9cb5aad0615fdfzhanyong.wan// For all other compilers, we assume RTTI is enabled. 36064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 36164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 36264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // _MSC_VER 36364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 36464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // GTEST_HAS_RTTI 36564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 366e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// It's this header's responsibility to #include <typeinfo> when RTTI 367e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// is enabled. 368e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#if GTEST_HAS_RTTI 369e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#include <typeinfo> 370e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#endif 371e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 3723bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// Determines whether Google Test can use the pthreads library. 373e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#ifndef GTEST_HAS_PTHREAD 3743bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// The user didn't tell us explicitly, so we assume pthreads support is 3753bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// available on Linux and Mac. 3763bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 3773bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 3783bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// to your compiler flags. 3793bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) 380e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_HAS_PTHREAD 381e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 382532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// Determines whether Google Test can use tr1/tuple. You can define 383532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// this macro to 0 to prevent Google Test from using tuple (any 384532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// feature depending on tuple with be disabled in this mode). 3853d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#ifndef GTEST_HAS_TR1_TUPLE 386532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// The user didn't tell us not to do it, so we assume it's OK. 387532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_HAS_TR1_TUPLE 1 388532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_HAS_TR1_TUPLE 389532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan 390532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// Determines whether Google Test's own tr1 tuple implementation 391532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// should be used. 392532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#ifndef GTEST_USE_OWN_TR1_TUPLE 3933d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// The user didn't tell us, so we need to figure it out. 3943d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 395fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// We use our own TR1 tuple if we aren't sure the user has an 396edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// implementation of it already. At this time, GCC 4.0.0+ and MSVC 397edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// 2010 are the only mainstream compilers that come with a TR1 tuple 398fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by 399fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// defining __GNUC__ and friends, but cannot compile GCC's tuple 400edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB 401edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// Feature Pack download, which we cannot assume the user has. 402fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ 403fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan || _MSC_VER >= 1600 404532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_USE_OWN_TR1_TUPLE 0 4053d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else 406532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_USE_OWN_TR1_TUPLE 1 407edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#endif 408532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan 409532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_USE_OWN_TR1_TUPLE 4103d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 4115145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// To avoid conditional compilation everywhere, we make it 4125145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// gtest-port.h's responsibility to #include the header implementing 4135145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple. 4145145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if GTEST_HAS_TR1_TUPLE 415e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 416532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#if GTEST_USE_OWN_TR1_TUPLE 417532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#include <gtest/internal/gtest-tuple.h> 418532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#elif GTEST_OS_SYMBIAN 419e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 420e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 421e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// use STLport's tuple implementation, which unfortunately doesn't 422e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// work as the copy of STLport distributed with Symbian is incomplete. 423e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 424e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// use its own tuple implementation. 425e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#ifdef BOOST_HAS_TR1_TUPLE 426e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#undef BOOST_HAS_TR1_TUPLE 427e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#endif // BOOST_HAS_TR1_TUPLE 428e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 429e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// This prevents <boost/tr1/detail/config.hpp>, which defines 430e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 431e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 432e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#include <tuple> 433e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 434e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 4359b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 4369b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// not conform to the TR1 spec, which requires the header to be <tuple>. 437683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan 438683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 439683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 440683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// which is #included by <tr1/tuple>, to not compile when RTTI is 441683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// disabled. _TR1_FUNCTIONAL is the header guard for 442683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// <tr1/functional>. Hence the following #define is a hack to prevent 443683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// <tr1/functional> from being included. 444683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#define _TR1_FUNCTIONAL 1 445683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#include <tr1/tuple> 446683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#undef _TR1_FUNCTIONAL // Allows the user to #include 447683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan // <tr1/functional> if he chooses to. 448683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#else 449edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#include <tr1/tuple> // NOLINT 450683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 451683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan 4525145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#else 4539b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// If the compiler is not GCC 4.0+, we assume the user is using a 4545145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// spec-conforming TR1 implementation. 455edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#include <tuple> // NOLINT 456532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_USE_OWN_TR1_TUPLE 457e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 4585145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif // GTEST_HAS_TR1_TUPLE 4595145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian 46004f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Determines whether clone(2) is supported. 46104f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Usually it will only be available on Linux, excluding 46204f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Linux on the Itanium architecture. 46304f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Also see http://linux.die.net/man/2/clone. 46404f025dd5746fca83c6c32f1729b3449721dd60eshiqian#ifndef GTEST_HAS_CLONE 46504f025dd5746fca83c6c32f1729b3449721dd60eshiqian// The user didn't tell us, so we need to figure it out. 46604f025dd5746fca83c6c32f1729b3449721dd60eshiqian 4670af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX && !defined(__ia64__) 46804f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 1 46904f025dd5746fca83c6c32f1729b3449721dd60eshiqian#else 47004f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 0 4710af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_LINUX && !defined(__ia64__) 47204f025dd5746fca83c6c32f1729b3449721dd60eshiqian 47304f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif // GTEST_HAS_CLONE 47404f025dd5746fca83c6c32f1729b3449721dd60eshiqian 47581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// Determines whether to support stream redirection. This is used to test 47681e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// output correctness and to implement death tests. 47781e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 47881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#define GTEST_HAS_STREAM_REDIRECTION_ 1 47981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 48081e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 481d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines whether to support death tests. 48288e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// Google Test does not support death tests for VC 7.1 and earlier as 48388e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// abort() in a VC 7.1 application compiled as GUI in debug config 48488e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// pops up a dialog window that cannot be suppressed programmatically. 485cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 48617e4860871d225bce440a3ca9ef1bdaceaed60d8zhanyong.wan (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 48717e4860871d225bce440a3ca9ef1bdaceaed60d8zhanyong.wan GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX) 4880af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_DEATH_TEST 1 4893c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <vector> // NOLINT 4909623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan#endif 491d201456903f3ecae1f7794edfab0d5678e64226shiqian 49212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// We don't support MSVC 7.1 with exceptions disabled now. Therefore 49312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// all the compilers we care about are adequate for supporting 49412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// value-parameterized tests. 4950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_PARAM_TEST 1 4963d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 497a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Determines whether to support type-driven tests. 498a2b1a8556ea64014606d78b09333d9c522430a25shiqian 49906d04c0945bf47bae90532552e6e8294802fc9aavladlosev// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, 50006d04c0945bf47bae90532552e6e8294802fc9aavladlosev// Sun Pro CC, and IBM Visual Age support. 50106d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 50206d04c0945bf47bae90532552e6e8294802fc9aavladlosev defined(__IBMCPP__) 503c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST 1 504c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST_P 1 505cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif 506a2b1a8556ea64014606d78b09333d9c522430a25shiqian 5073d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support Combine(). This only makes sense when 508e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// value-parameterized tests are enabled. The implementation doesn't 509e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// work on Sun Studio since it doesn't understand templated conversion 510e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// operators. 511e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 5120af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_COMBINE 1 513e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#endif 5143d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 5150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Determines whether the system compiler uses UTF-16 for encoding wide strings. 5160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_WIDE_STRING_USES_UTF16_ \ 51706d04c0945bf47bae90532552e6e8294802fc9aavladlosev (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 5180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 519d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines some utility macros. 520d201456903f3ecae1f7794edfab0d5678e64226shiqian 521d201456903f3ecae1f7794edfab0d5678e64226shiqian// The GNU compiler emits a warning if nested "if" statements are followed by 522d201456903f3ecae1f7794edfab0d5678e64226shiqian// an "else" statement and braces are not used to explicitly disambiguate the 523d201456903f3ecae1f7794edfab0d5678e64226shiqian// "else" binding. This leads to problems with code like: 524d201456903f3ecae1f7794edfab0d5678e64226shiqian// 525d201456903f3ecae1f7794edfab0d5678e64226shiqian// if (gate) 526d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_*(condition) << "Some message"; 527d201456903f3ecae1f7794edfab0d5678e64226shiqian// 528d201456903f3ecae1f7794edfab0d5678e64226shiqian// The "switch (0) case 0:" idiom is used to suppress this. 529d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __INTEL_COMPILER 530e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 531d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 532e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 533d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 534d201456903f3ecae1f7794edfab0d5678e64226shiqian 5350da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Use this annotation at the end of a struct/class definition to 536d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent the compiler from optimizing away instances that are never 537d201456903f3ecae1f7794edfab0d5678e64226shiqian// used. This is useful when all interesting logic happens inside the 538d201456903f3ecae1f7794edfab0d5678e64226shiqian// c'tor and / or d'tor. Example: 539d201456903f3ecae1f7794edfab0d5678e64226shiqian// 540d201456903f3ecae1f7794edfab0d5678e64226shiqian// struct Foo { 541d201456903f3ecae1f7794edfab0d5678e64226shiqian// Foo() { ... } 542e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// } GTEST_ATTRIBUTE_UNUSED_; 5430da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// 5440da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Also use it after a variable or parameter declaration to tell the 5450da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// compiler the variable/parameter does not have to be used. 546bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#if defined(__GNUC__) && !defined(COMPILER_ICC) 547e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 548bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#else 549e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ 550bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#endif 551d201456903f3ecae1f7794edfab0d5678e64226shiqian 5527b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// A macro to disallow operator= 5537b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// This should be used in the private: declarations for a class. 5547b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#define GTEST_DISALLOW_ASSIGN_(type)\ 5557b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan void operator=(type const &) 5567b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan 5577b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// A macro to disallow copy constructor and operator= 558d201456903f3ecae1f7794edfab0d5678e64226shiqian// This should be used in the private: declarations for a class. 559e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 5607b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan type(type const &);\ 5617b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan GTEST_DISALLOW_ASSIGN_(type) 562d201456903f3ecae1f7794edfab0d5678e64226shiqian 563d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tell the compiler to warn about unused return values for functions declared 564d201456903f3ecae1f7794edfab0d5678e64226shiqian// with this macro. The macro should be used on function declarations 565d201456903f3ecae1f7794edfab0d5678e64226shiqian// following the argument list: 566d201456903f3ecae1f7794edfab0d5678e64226shiqian// 567e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 56864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 569e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 570d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 571e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ 57264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 573d201456903f3ecae1f7794edfab0d5678e64226shiqian 574f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Determine whether the compiler supports Microsoft's Structured Exception 575f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Handling. This is supported by several Windows compilers but generally 576f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// does not exist on any other system. 577f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#ifndef GTEST_HAS_SEH 578f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// The user didn't tell us, so we need to figure it out. 579f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 580f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 581f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// These two compilers are known to support SEH. 582f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 1 583f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#else 584f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Assume no SEH. 585f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 0 586f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif 587f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 588f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif // GTEST_HAS_SEH 589f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 59083589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#ifdef _MSC_VER 59183589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan 59283589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#if GTEST_LINKED_AS_SHARED_LIBRARY 59383589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#define GTEST_API_ __declspec(dllimport) 59483589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#elif GTEST_CREATE_SHARED_LIBRARY 59583589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#define GTEST_API_ __declspec(dllexport) 59683589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#endif 59783589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan 59883589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#endif // _MSC_VER 59983589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan 60083589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#ifndef GTEST_API_ 60183589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#define GTEST_API_ 60283589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#endif 60383589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan 604d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 605d201456903f3ecae1f7794edfab0d5678e64226shiqian 606d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message; 607d201456903f3ecae1f7794edfab0d5678e64226shiqian 608d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 609d201456903f3ecae1f7794edfab0d5678e64226shiqian 610d201456903f3ecae1f7794edfab0d5678e64226shiqianclass String; 611d201456903f3ecae1f7794edfab0d5678e64226shiqian 612d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::stringstream StrStream; 613d201456903f3ecae1f7794edfab0d5678e64226shiqian 614f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// A helper for suppressing warnings on constant condition. It just 615f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// returns 'condition'. 61683589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wanGTEST_API_ bool IsTrue(bool condition); 617f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan 618d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines scoped_ptr. 619d201456903f3ecae1f7794edfab0d5678e64226shiqian 620d201456903f3ecae1f7794edfab0d5678e64226shiqian// This implementation of scoped_ptr is PARTIAL - it only contains 621d201456903f3ecae1f7794edfab0d5678e64226shiqian// enough stuff to satisfy Google Test's need. 622d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 623d201456903f3ecae1f7794edfab0d5678e64226shiqianclass scoped_ptr { 624d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 625b6fe6899bef6dd90572fc0e7f12912d9ad87a19evladlosev typedef T element_type; 626b6fe6899bef6dd90572fc0e7f12912d9ad87a19evladlosev 627d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 628d201456903f3ecae1f7794edfab0d5678e64226shiqian ~scoped_ptr() { reset(); } 629d201456903f3ecae1f7794edfab0d5678e64226shiqian 630d201456903f3ecae1f7794edfab0d5678e64226shiqian T& operator*() const { return *ptr_; } 631d201456903f3ecae1f7794edfab0d5678e64226shiqian T* operator->() const { return ptr_; } 632d201456903f3ecae1f7794edfab0d5678e64226shiqian T* get() const { return ptr_; } 633d201456903f3ecae1f7794edfab0d5678e64226shiqian 634d201456903f3ecae1f7794edfab0d5678e64226shiqian T* release() { 635d201456903f3ecae1f7794edfab0d5678e64226shiqian T* const ptr = ptr_; 636d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = NULL; 637d201456903f3ecae1f7794edfab0d5678e64226shiqian return ptr; 638d201456903f3ecae1f7794edfab0d5678e64226shiqian } 639d201456903f3ecae1f7794edfab0d5678e64226shiqian 640d201456903f3ecae1f7794edfab0d5678e64226shiqian void reset(T* p = NULL) { 641d201456903f3ecae1f7794edfab0d5678e64226shiqian if (p != ptr_) { 642f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 643d201456903f3ecae1f7794edfab0d5678e64226shiqian delete ptr_; 644d201456903f3ecae1f7794edfab0d5678e64226shiqian } 645d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = p; 646d201456903f3ecae1f7794edfab0d5678e64226shiqian } 647d201456903f3ecae1f7794edfab0d5678e64226shiqian } 648d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 649d201456903f3ecae1f7794edfab0d5678e64226shiqian T* ptr_; 650d201456903f3ecae1f7794edfab0d5678e64226shiqian 651e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 652d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 653d201456903f3ecae1f7794edfab0d5678e64226shiqian 6543d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Defines RE. 655d201456903f3ecae1f7794edfab0d5678e64226shiqian 65606d04c0945bf47bae90532552e6e8294802fc9aavladlosev// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended 657d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular Expression syntax. 65883589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wanclass GTEST_API_ RE { 659d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 66006d04c0945bf47bae90532552e6e8294802fc9aavladlosev // A copy constructor is required by the Standard to initialize object 66106d04c0945bf47bae90532552e6e8294802fc9aavladlosev // references from r-values. 66206d04c0945bf47bae90532552e6e8294802fc9aavladlosev RE(const RE& other) { Init(other.pattern()); } 66306d04c0945bf47bae90532552e6e8294802fc9aavladlosev 664d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs an RE from a string. 665d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 666d201456903f3ecae1f7794edfab0d5678e64226shiqian 667d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 668d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 669d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 670d201456903f3ecae1f7794edfab0d5678e64226shiqian 671d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const char* regex) { Init(regex); } // NOLINT 672d201456903f3ecae1f7794edfab0d5678e64226shiqian ~RE(); 673d201456903f3ecae1f7794edfab0d5678e64226shiqian 674d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the string representation of the regex. 675d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern() const { return pattern_; } 676d201456903f3ecae1f7794edfab0d5678e64226shiqian 6773d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // FullMatch(str, re) returns true iff regular expression re matches 6783d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // the entire str. 6793d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // PartialMatch(str, re) returns true iff regular expression re 6803d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // matches a substring of str (including str itself). 6813d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // 6823d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // TODO(wan@google.com): make FullMatch() and PartialMatch() work 6833d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // when str contains NUL characters. 6843d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::std::string& str, const RE& re) { 6853d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 6863d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 687d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::std::string& str, const RE& re) { 688d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 689d201456903f3ecae1f7794edfab0d5678e64226shiqian } 690d201456903f3ecae1f7794edfab0d5678e64226shiqian 691d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 6923d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::string& str, const RE& re) { 6933d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 6943d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 695d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::string& str, const RE& re) { 696d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 697d201456903f3ecae1f7794edfab0d5678e64226shiqian } 698d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 699d201456903f3ecae1f7794edfab0d5678e64226shiqian 7003d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const char* str, const RE& re); 701d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const char* str, const RE& re); 702d201456903f3ecae1f7794edfab0d5678e64226shiqian 703d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 704d201456903f3ecae1f7794edfab0d5678e64226shiqian void Init(const char* regex); 705d201456903f3ecae1f7794edfab0d5678e64226shiqian 706d201456903f3ecae1f7794edfab0d5678e64226shiqian // We use a const char* instead of a string, as Google Test may be used 707d201456903f3ecae1f7794edfab0d5678e64226shiqian // where string is not available. We also do not use Google Test's own 708d201456903f3ecae1f7794edfab0d5678e64226shiqian // String type here, in order to simplify dependencies between the 709d201456903f3ecae1f7794edfab0d5678e64226shiqian // files. 710d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern_; 711c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan bool is_valid_; 712c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#if GTEST_USES_POSIX_RE 7133d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t full_regex_; // For FullMatch(). 7143d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t partial_regex_; // For PartialMatch(). 715c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else // GTEST_USES_SIMPLE_RE 716c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan const char* full_pattern_; // For FullMatch(); 717c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#endif 718d201456903f3ecae1f7794edfab0d5678e64226shiqian 71906d04c0945bf47bae90532552e6e8294802fc9aavladlosev GTEST_DISALLOW_ASSIGN_(RE); 720c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan}; 721d201456903f3ecae1f7794edfab0d5678e64226shiqian 722d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines logging utilities: 723866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// GTEST_LOG_(severity) - logs messages at the specified severity level. The 724866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// message itself is streamed into the macro. 725d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 726d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 727d201456903f3ecae1f7794edfab0d5678e64226shiqian 728d201456903f3ecae1f7794edfab0d5678e64226shiqianenum GTestLogSeverity { 729d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_INFO, 730d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_WARNING, 731d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_ERROR, 732d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FATAL 733d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 734d201456903f3ecae1f7794edfab0d5678e64226shiqian 735866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// Formats log entry severity, provides a stream object for streaming the 736866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// log message, and terminates the message with a newline when going out of 737866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// scope. 73883589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wanclass GTEST_API_ GTestLog { 739866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan public: 740866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan GTestLog(GTestLogSeverity severity, const char* file, int line); 741866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 742866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 743866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ~GTestLog(); 744866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 745866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ::std::ostream& GetStream() { return ::std::cerr; } 746866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 747866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan private: 748866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan const GTestLogSeverity severity_; 749866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 750866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 751866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan}; 752d201456903f3ecae1f7794edfab0d5678e64226shiqian 753866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan#define GTEST_LOG_(severity) \ 754866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 755866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan __FILE__, __LINE__).GetStream() 756d201456903f3ecae1f7794edfab0d5678e64226shiqian 757d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void LogToStderr() {} 758d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void FlushInfoLog() { fflush(NULL); } 759d201456903f3ecae1f7794edfab0d5678e64226shiqian 7603bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// INTERNAL IMPLEMENTATION - DO NOT USE. 7613bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 7623bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 7633bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// is not satisfied. 7643bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// Synopsys: 7653bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// GTEST_CHECK_(boolean_condition); 7663bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// or 7673bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// GTEST_CHECK_(boolean_condition) << "Additional message"; 7683bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 7693bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// This checks the condition and if the condition is not satisfied 7703bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// it prints message about the condition violation, including the 7713bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// condition itself, plus additional message streamed into it, if any, 7723bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// and then it aborts the program. It aborts the program irrespective of 7733bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// whether it is built in the debug mode or not. 7743bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_CHECK_(condition) \ 7753bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 7763bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan if (::testing::internal::IsTrue(condition)) \ 7773bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan ; \ 7783bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan else \ 7793bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 7803bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 7814879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// An all-mode assert to verify that the given POSIX-style function 7824879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// call returns 0 (indicating success). Known limitation: this 7834879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// doesn't expand to a balanced 'if' statement, so enclose the macro 7844879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// in {} if you need to use it as the only statement in an 'if' 7854879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// branch. 7864879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 7874879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan if (const int gtest_error = (posix_call)) \ 7884879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 7894879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan << gtest_error 7904879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan 791e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 792e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// 793e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// Downcasts the pointer of type Base to Derived. 794e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// Derived must be a subclass of Base. The parameter MUST 795e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// point to a class of type Derived, not any subclass of it. 796e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// When RTTI is available, the function performs a runtime 797e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// check to enforce this. 798e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wantemplate <class Derived, class Base> 799e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wanDerived* CheckedDowncastToActualType(Base* base) { 800e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#if GTEST_HAS_RTTI 801e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan GTEST_CHECK_(typeid(*base) == typeid(Derived)); 802e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan return dynamic_cast<Derived*>(base); // NOLINT 803e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan#else 804e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan return static_cast<Derived*>(base); // Poor man's downcast. 80592344b762a86bd73d79a0db8999ece92fb5069fazhanyong.wan#endif 806e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan} 807e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 80881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION_ 809fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 810d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines the stderr capturer: 811fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// CaptureStdout - starts capturing stdout. 812fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// GetCapturedStdout - stops capturing stdout and returns the captured string. 813d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr - starts capturing stderr. 814d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr - stops capturing stderr and returns the captured string. 815fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// 8169f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ void CaptureStdout(); 8179f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ String GetCapturedStdout(); 8189f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ void CaptureStderr(); 8199f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ String GetCapturedStderr(); 8204984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 82181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#endif // GTEST_HAS_STREAM_REDIRECTION_ 822fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 823fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 8240af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 825d201456903f3ecae1f7794edfab0d5678e64226shiqian 826d201456903f3ecae1f7794edfab0d5678e64226shiqian// A copy of all command line arguments. Set by InitGoogleTest(). 827d201456903f3ecae1f7794edfab0d5678e64226shiqianextern ::std::vector<String> g_argvs; 828d201456903f3ecae1f7794edfab0d5678e64226shiqian 829d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_DEATH_TEST implies we have ::std::string. 830d201456903f3ecae1f7794edfab0d5678e64226shiqianconst ::std::vector<String>& GetArgvs(); 831d201456903f3ecae1f7794edfab0d5678e64226shiqian 832d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_DEATH_TEST 833d201456903f3ecae1f7794edfab0d5678e64226shiqian 834d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines synchronization primitives. 835d201456903f3ecae1f7794edfab0d5678e64226shiqian 8363bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#if GTEST_HAS_PTHREAD 8373bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 83812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// Sleeps for (roughly) n milli-seconds. This function is only for 83912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// testing Google Test's own constructs. Don't use it in user tests, 84012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// either directly or indirectly. 84112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.waninline void SleepMilliseconds(int n) { 84212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan const timespec time = { 84312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 0, // 0 seconds. 84412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan n * 1000L * 1000L, // And n ms. 84512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan }; 84612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan nanosleep(&time, NULL); 84712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan} 84812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 84912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// Allows a controller thread to pause execution of newly created 85012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// threads until notified. Instances of this class must be created 85112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// and destroyed in the controller thread. 85212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// 85312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// This class is only for testing Google Test's own constructs. Do not 85412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// use it in user tests, either directly or indirectly. 85512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wanclass Notification { 85612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan public: 85712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan Notification() : notified_(false) {} 85812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 85912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // Notifies all threads created with this notification to start. Must 86012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // be called from the controller thread. 86112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan void Notify() { notified_ = true; } 86212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 86312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // Blocks until the controller thread notifies. Must be called from a test 86412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // thread. 86512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan void WaitForNotification() { 86612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan while(!notified_) { 86712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan SleepMilliseconds(10); 86812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan } 86912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan } 87012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 87112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan private: 87212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan volatile bool notified_; 87312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 87412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 87512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan}; 87612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 87706d04c0945bf47bae90532552e6e8294802fc9aavladlosev// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. 87806d04c0945bf47bae90532552e6e8294802fc9aavladlosev// Consequently, it cannot select a correct instantiation of ThreadWithParam 87906d04c0945bf47bae90532552e6e8294802fc9aavladlosev// in order to call its Run(). Introducing ThreadWithParamBase as a 88006d04c0945bf47bae90532552e6e8294802fc9aavladlosev// non-templated base class for ThreadWithParam allows us to bypass this 88106d04c0945bf47bae90532552e6e8294802fc9aavladlosev// problem. 88206d04c0945bf47bae90532552e6e8294802fc9aavladlosevclass ThreadWithParamBase { 88306d04c0945bf47bae90532552e6e8294802fc9aavladlosev public: 88406d04c0945bf47bae90532552e6e8294802fc9aavladlosev virtual ~ThreadWithParamBase() {} 88506d04c0945bf47bae90532552e6e8294802fc9aavladlosev virtual void Run() = 0; 88606d04c0945bf47bae90532552e6e8294802fc9aavladlosev}; 88706d04c0945bf47bae90532552e6e8294802fc9aavladlosev 88806d04c0945bf47bae90532552e6e8294802fc9aavladlosev// pthread_create() accepts a pointer to a function type with the C linkage. 88906d04c0945bf47bae90532552e6e8294802fc9aavladlosev// According to the Standard (7.5/1), function types with different linkages 89006d04c0945bf47bae90532552e6e8294802fc9aavladlosev// are different even if they are otherwise identical. Some compilers (for 89106d04c0945bf47bae90532552e6e8294802fc9aavladlosev// example, SunStudio) treat them as different types. Since class methods 89206d04c0945bf47bae90532552e6e8294802fc9aavladlosev// cannot be defined with C-linkage we need to define a free C-function to 89306d04c0945bf47bae90532552e6e8294802fc9aavladlosev// pass into pthread_create(). 89406d04c0945bf47bae90532552e6e8294802fc9aavladlosevextern "C" inline void* ThreadFuncWithCLinkage(void* thread) { 89506d04c0945bf47bae90532552e6e8294802fc9aavladlosev static_cast<ThreadWithParamBase*>(thread)->Run(); 89606d04c0945bf47bae90532552e6e8294802fc9aavladlosev return NULL; 89706d04c0945bf47bae90532552e6e8294802fc9aavladlosev} 89806d04c0945bf47bae90532552e6e8294802fc9aavladlosev 89912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// Helper class for testing Google Test's multi-threading constructs. 900542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan// To use it, write: 90112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// 90212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// void ThreadFunc(int param) { /* Do things with param */ } 90312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// Notification thread_can_start; 90412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// ... 90512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// // The thread_can_start parameter is optional; you can supply NULL. 90612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); 90712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// thread_can_start.Notify(); 90812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// 90912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// These classes are only for testing Google Test's own constructs. Do 91012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan// not use them in user tests, either directly or indirectly. 91112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wantemplate <typename T> 91206d04c0945bf47bae90532552e6e8294802fc9aavladlosevclass ThreadWithParam : public ThreadWithParamBase { 91312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan public: 91412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan typedef void (*UserThreadFunc)(T); 91512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 916542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan ThreadWithParam( 91712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan UserThreadFunc func, T param, Notification* thread_can_start) 91812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan : func_(func), 91912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan param_(param), 92012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan thread_can_start_(thread_can_start), 921542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan finished_(false) { 922e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan ThreadWithParamBase* const base = this; 923542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan // The thread can be created only after all fields except thread_ 924542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan // have been initialized. 925542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan GTEST_CHECK_POSIX_SUCCESS_( 926e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); 927542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan } 928542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan ~ThreadWithParam() { Join(); } 92912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 93012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan void Join() { 93112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan if (!finished_) { 932542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); 93312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan finished_ = true; 93412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan } 93512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan } 93612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 93706d04c0945bf47bae90532552e6e8294802fc9aavladlosev virtual void Run() { 93812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan if (thread_can_start_ != NULL) 93912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan thread_can_start_->WaitForNotification(); 94012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan func_(param_); 94112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan } 94212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 94306d04c0945bf47bae90532552e6e8294802fc9aavladlosev private: 94412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan const UserThreadFunc func_; // User-supplied thread function. 94512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan const T param_; // User-supplied parameter to the thread function. 94612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // When non-NULL, used to block execution until the controller thread 94712a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan // notifies. 94812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan Notification* const thread_can_start_; 94912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan bool finished_; // true iff we know that the thread function has finished. 950542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan pthread_t thread_; // The native thread object. 951542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan 952542b41e5d010cf0a18a37252d5f4b05cfa5408afzhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 95312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan}; 95412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 9553bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is 9563bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// true. 9573bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#include <pthread.h> 9583bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 9593bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// MutexBase and Mutex implement mutex on pthreads-based platforms. They 9603bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// are used in conjunction with class MutexLock: 9613bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9624879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// Mutex mutex; 9634879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// ... 9644879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end 9654879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// // of the current scope. 9663bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9673bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// MutexBase implements behavior for both statically and dynamically 9684879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// allocated mutexes. Do not use MutexBase directly. Instead, write 9694879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// the following to define a static mutex: 9703bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9714879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); 9723bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9734879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// You can forward declare a static mutex like this: 9743bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9754879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); 9763bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 9774879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// To create a dynamic mutex, just define an object of type Mutex. 9783bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wanclass MutexBase { 9793bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan public: 9804879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // Acquires this mutex. 9814879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan void Lock() { 9824879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); 9834879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan owner_ = pthread_self(); 9844879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan } 9854879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan 9864879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // Releases this mutex. 9874879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan void Unlock() { 9884879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // We don't protect writing to owner_ here, as it's the caller's 9894879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // responsibility to ensure that the current thread holds the 9904879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // mutex when this is called. 9914879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan owner_ = 0; 9924879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); 9934879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan } 9943bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 9953bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan // Does nothing if the current thread holds the mutex. Otherwise, crashes 9963bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan // with high probability. 9974879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan void AssertHeld() const { 9984879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_(owner_ == pthread_self()) 9994879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan << "The current thread is not holding the mutex @" << this; 10004879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan } 10013bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10024879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // A static mutex may be used before main() is entered. It may even 10034879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // be used before the dynamic initialization stage. Therefore we 10044879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // must be able to initialize a static mutex object at link time. 10054879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // This means MutexBase has to be a POD and its member variables 10064879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan // have to be public. 10073bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan public: 10084879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan pthread_mutex_t mutex_; // The underlying pthread mutex. 10094879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan pthread_t owner_; // The thread holding the mutex; 0 means no one holds it. 10103bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan}; 10113bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10123bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// Forward-declares a static mutex. 10133bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 10143bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan extern ::testing::internal::MutexBase mutex 10153bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10164879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// Defines and statically (i.e. at link time) initializes a static mutex. 10173bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 10183bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 } 10193bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10204879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// The Mutex class can only be used for mutexes created at runtime. It 10214879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// shares its API with MutexBase otherwise. 10223bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wanclass Mutex : public MutexBase { 10233bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan public: 10244879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan Mutex() { 10254879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 10264879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan owner_ = 0; 10274879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan } 10284879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan ~Mutex() { 10294879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); 10304879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan } 10313bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10323bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan private: 10333bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 10343bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan}; 10353bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10364879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// We cannot name this class MutexLock as the ctor declaration would 10373bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// conflict with a macro named MutexLock, which is defined on some 10383bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// platforms. Hence the typedef trick below. 10393bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wanclass GTestMutexLock { 10403bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan public: 10413bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan explicit GTestMutexLock(MutexBase* mutex) 10423bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan : mutex_(mutex) { mutex_->Lock(); } 10433bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10443bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan ~GTestMutexLock() { mutex_->Unlock(); } 10453bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10463bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan private: 10473bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan MutexBase* const mutex_; 10483bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10493bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 10503bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan}; 10513bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10523bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wantypedef GTestMutexLock MutexLock; 10533bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 1054e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// Helpers for ThreadLocal. 1055e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 1056e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// pthread_key_create() requires DeleteThreadLocalValue() to have 1057e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// C-linkage. Therefore it cannot be templatized to access 1058e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// ThreadLocal<T>. Hence the need for class 1059e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// ThreadLocalValueHolderBase. 1060e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wanclass ThreadLocalValueHolderBase { 1061e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan public: 1062e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan virtual ~ThreadLocalValueHolderBase() {} 1063e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan}; 1064e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 1065e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// Called by pthread to delete thread-local data stored by 1066e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan// pthread_setspecific(). 1067e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wanextern "C" inline void DeleteThreadLocalValue(void* value_holder) { 1068e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan delete static_cast<ThreadLocalValueHolderBase*>(value_holder); 1069e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan} 1070e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 10713bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// Implements thread-local storage on pthreads-based systems. 10723bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 10734879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// // Thread 1 10744879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// ThreadLocal<int> tl(100); // 100 is the default value for each thread. 10753bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 10764879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// // Thread 2 10774879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// tl.set(150); // Changes the value for thread 2 only. 10784879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// EXPECT_EQ(150, tl.get()); 10793bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 10804879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// // Thread 1 10814879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. 10824879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// tl.set(200); 10834879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// EXPECT_EQ(200, tl.get()); 10843bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// 10854879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// The template type argument T must have a public copy constructor. 10864879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// In addition, the default ThreadLocal constructor requires T to have 10874879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// a public default constructor. An object managed by a ThreadLocal 10884879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// instance for a thread is guaranteed to exist at least until the 10894879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// earliest of the two events: (a) the thread terminates or (b) the 10904879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan// ThreadLocal object is destroyed. 10913bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wantemplate <typename T> 10923bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wanclass ThreadLocal { 10933bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan public: 10944879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan ThreadLocal() : key_(CreateKey()), 10954879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan default_() {} 10964879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan explicit ThreadLocal(const T& value) : key_(CreateKey()), 10974879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan default_(value) {} 10983bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 10993bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan ~ThreadLocal() { 11004879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); 11013bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan } 11023bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11033bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan T* pointer() { return GetOrCreateValue(); } 11043bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan const T* pointer() const { return GetOrCreateValue(); } 11053bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan const T& get() const { return *pointer(); } 11063bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan void set(const T& value) { *pointer() = value; } 11073bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11083bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan private: 1109e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan // Holds a value of type T. 1110e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan class ValueHolder : public ThreadLocalValueHolderBase { 1111e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan public: 1112e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan explicit ValueHolder(const T& value) : value_(value) {} 1113e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 1114e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan T* pointer() { return &value_; } 1115e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 1116e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan private: 1117e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan T value_; 1118e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 1119e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan }; 1120e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan 11213bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan static pthread_key_t CreateKey() { 11223bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan pthread_key_t key; 1123e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan GTEST_CHECK_POSIX_SUCCESS_( 1124e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan pthread_key_create(&key, &DeleteThreadLocalValue)); 11253bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan return key; 11263bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan } 11273bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11283bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan T* GetOrCreateValue() const { 1129e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan ThreadLocalValueHolderBase* const holder = 1130e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); 1131e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan if (holder != NULL) { 1132e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); 1133e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan } 11344879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan 1135e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan ValueHolder* const new_holder = new ValueHolder(default_); 1136e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan ThreadLocalValueHolderBase* const holder_base = new_holder; 1137e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); 1138e9f093ae15ac232f7ac0a31d64a5873fd1e306c6zhanyong.wan return new_holder->pointer(); 11393bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan } 11403bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11413bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan // A key pthreads uses for looking up per-thread values. 11423bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan const pthread_key_t key_; 11434879aac74991ad4552c5ed2ec178af511f3feb5ezhanyong.wan const T default_; // The default value for each thread. 11443bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11453bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 11463bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan}; 11473bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11483bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_IS_THREADSAFE 1 11493bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11503bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#else // GTEST_HAS_PTHREAD 11513bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 1152d201456903f3ecae1f7794edfab0d5678e64226shiqian// A dummy implementation of synchronization primitives (mutex, lock, 1153d201456903f3ecae1f7794edfab0d5678e64226shiqian// and thread-local variable). Necessary for compiling Google Test where 1154d201456903f3ecae1f7794edfab0d5678e64226shiqian// mutex is not supported - using Google Test in multiple threads is not 1155d201456903f3ecae1f7794edfab0d5678e64226shiqian// supported on such platforms. 1156d201456903f3ecae1f7794edfab0d5678e64226shiqian 1157d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Mutex { 1158d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 1159d201456903f3ecae1f7794edfab0d5678e64226shiqian Mutex() {} 1160d201456903f3ecae1f7794edfab0d5678e64226shiqian void AssertHeld() const {} 1161d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1162d201456903f3ecae1f7794edfab0d5678e64226shiqian 11633bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 11643bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan extern ::testing::internal::Mutex mutex 11653bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11663bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 11673bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 1168d201456903f3ecae1f7794edfab0d5678e64226shiqianclass GTestMutexLock { 1169d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 1170d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit GTestMutexLock(Mutex*) {} // NOLINT 1171d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1172d201456903f3ecae1f7794edfab0d5678e64226shiqian 1173d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef GTestMutexLock MutexLock; 1174d201456903f3ecae1f7794edfab0d5678e64226shiqian 1175d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 1176d201456903f3ecae1f7794edfab0d5678e64226shiqianclass ThreadLocal { 1177d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 1178e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal() : value_() {} 1179e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian explicit ThreadLocal(const T& value) : value_(value) {} 1180d201456903f3ecae1f7794edfab0d5678e64226shiqian T* pointer() { return &value_; } 1181d201456903f3ecae1f7794edfab0d5678e64226shiqian const T* pointer() const { return &value_; } 1182d201456903f3ecae1f7794edfab0d5678e64226shiqian const T& get() const { return value_; } 1183d201456903f3ecae1f7794edfab0d5678e64226shiqian void set(const T& value) { value_ = value; } 1184d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1185d201456903f3ecae1f7794edfab0d5678e64226shiqian T value_; 1186d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1187d201456903f3ecae1f7794edfab0d5678e64226shiqian 1188e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The above synchronization primitives have dummy implementations. 1189e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Therefore Google Test is not thread-safe. 1190e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_IS_THREADSAFE 0 1191e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 11923bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan#endif // GTEST_HAS_PTHREAD 11933bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 11943bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// Returns the number of threads running in the process, or 0 to indicate that 11953bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan// we cannot detect it. 11969f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ size_t GetThreadCount(); 11973bef459eac9aa84c579f34249aebc9ff56832054zhanyong.wan 1198d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Passing non-POD classes through ellipsis (...) crashes the ARM 119944bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// compiler and generates a warning in Sun Studio. The Nokia Symbian 120044bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// and the IBM XL C/C++ compiler try to instantiate a copy constructor 120144bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// for objects passed through ellipsis (...), failing for uncopyable 120244bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// objects. We define this to ensure that only POD is passed through 120344bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// ellipsis on these systems. 120444bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 120506d04c0945bf47bae90532552e6e8294802fc9aavladlosev// We lose support for NULL detection where the compiler doesn't like 120606d04c0945bf47bae90532552e6e8294802fc9aavladlosev// passing non-POD classes through ellipsis (...). 120744bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#define GTEST_ELLIPSIS_NEEDS_POD_ 1 120806d04c0945bf47bae90532552e6e8294802fc9aavladlosev#else 120906d04c0945bf47bae90532552e6e8294802fc9aavladlosev#define GTEST_CAN_COMPARE_NULL 1 121044bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#endif 1211d201456903f3ecae1f7794edfab0d5678e64226shiqian 1212d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 1213d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// const T& and const T* in a function template. These compilers 1214d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// _can_ decide between class template specializations for T and T*, 1215d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// so a tr1::type_traits-like is_pointer works. 121644bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 1217d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_NEEDS_IS_POINTER_ 1 121844bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#endif 1219d201456903f3ecae1f7794edfab0d5678e64226shiqian 1220d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> 1221d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct bool_constant { 1222d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef bool_constant<bool_value> type; 1223d201456903f3ecae1f7794edfab0d5678e64226shiqian static const bool value = bool_value; 1224d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1225d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> const bool bool_constant<bool_value>::value; 1226d201456903f3ecae1f7794edfab0d5678e64226shiqian 1227d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<false> false_type; 1228d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<true> true_type; 1229d201456903f3ecae1f7794edfab0d5678e64226shiqian 1230d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 1231d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer : public false_type {}; 1232d201456903f3ecae1f7794edfab0d5678e64226shiqian 1233d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 1234d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer<T*> : public true_type {}; 1235d201456903f3ecae1f7794edfab0d5678e64226shiqian 123687d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#if GTEST_OS_WINDOWS 123787d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "\\" 12388d373310561a8d68d2a22ca7c6613deff5fa6e05zhanyong.wan#define GTEST_HAS_ALT_PATH_SEP_ 1 12393c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The biggest signed integer type the compiler supports. 12403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef __int64 BiggestInt; 124187d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#else 124287d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "/" 12438d373310561a8d68d2a22ca7c6613deff5fa6e05zhanyong.wan#define GTEST_HAS_ALT_PATH_SEP_ 0 12443c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef long long BiggestInt; // NOLINT 124587d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#endif // GTEST_OS_WINDOWS 124687d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan 12473c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The testing::internal::posix namespace holds wrappers for common 12483c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// POSIX functions. These wrappers hide the differences between 1249f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// Windows/MSVC and POSIX systems. Since some compilers define these 1250f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// standard functions as macros, the wrapper cannot have the same name 1251f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// as the wrapped function. 1252f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan 12533c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wannamespace posix { 12543c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 12553c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions with a different name on Windows. 12563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 12570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 12583c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1259f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct _stat StatStruct; 12603c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1261c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1262c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 1263c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 1264c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return stricmp(s1, s2); 1265c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1266c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 12674853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#else // !__BORLANDC__ 1268b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 12694853a503371f39aa22e14adcdecea71c09841e34zhanyong.waninline int IsATTY(int /* fd */) { return 0; } 1270b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 1271f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return _isatty(fd); } 1272b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 1273f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 1274f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return _stricmp(s1, s2); 12753c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1276f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline char* StrDup(const char* src) { return _strdup(src); } 1277c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // __BORLANDC__ 1278c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1279b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 12804853a503371f39aa22e14adcdecea71c09841e34zhanyong.waninline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 12814853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 12824853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// time and thus not defined there. 1283b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 1284c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int FileNo(FILE* file) { return _fileno(file); } 1285c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 1286f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return _rmdir(dir); } 1287f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { 12883c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return (_S_IFDIR & st.st_mode) != 0; 12893c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1290b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 12913c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1292d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 12933c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1294f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct stat StatStruct; 12953c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1296f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FileNo(FILE* file) { return fileno(file); } 1297f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 1298f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 1299f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 1300f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strcasecmp(s1, s2); 1301f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan} 1302c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 1303f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return rmdir(dir); } 1304f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 13053c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1306d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 1307d201456903f3ecae1f7794edfab0d5678e64226shiqian 13083c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions deprecated by MSVC 8.0. 13093c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 13103c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 13113c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Temporarily disable warning 4996 (deprecated function). 13123c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(push) 13133c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(disable:4996) 13143c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 13153c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1316f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrNCpy(char* dest, const char* src, size_t n) { 1317f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strncpy(dest, src, n); 13183c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 13194853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan 13204853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 13214853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// StrError() aren't needed on Windows CE at this time and thus not 13224853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// defined there. 13234853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan 1324b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1325f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int ChDir(const char* dir) { return chdir(dir); } 13264853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 1327f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FOpen(const char* path, const char* mode) { 1328f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return fopen(path, mode); 13293c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1330b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1331f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 1332f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return freopen(path, mode, stream); 13333c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1334f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 13354853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 1336f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FClose(FILE* fp) { return fclose(fp); } 1337b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1338f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Read(int fd, void* buf, unsigned int count) { 1339f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(read(fd, buf, count)); 13403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1341f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Write(int fd, const void* buf, unsigned int count) { 1342f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(write(fd, buf, count)); 13433c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 1344f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Close(int fd) { return close(fd); } 1345f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrError(int errnum) { return strerror(errnum); } 13464853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 1347f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* GetEnv(const char* name) { 1348b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 1349b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan // We are on Windows CE, which has no environment variables. 13503c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return NULL; 1351cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 1352c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Environment variables which we programmatically clear will be set to the 1353c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // empty string rather than unset (NULL). Handle that case. 1354c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const char* const env = getenv(name); 1355c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return (env != NULL && env[0] != '\0') ? env : NULL; 13563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 1357f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return getenv(name); 13583c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 13593c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 13603c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 13613c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 13623c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(pop) // Restores the warning state. 13633c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 13643c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1365b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 13663c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Windows CE has no C library. The abort() function is used in 13673c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// several places in Google Test. This implementation provides a reasonable 13683c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// imitation of standard behaviour. 1369f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wanvoid Abort(); 13703c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 1371f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline void Abort() { abort(); } 1372b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 13733c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 13743c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} // namespace posix 13753c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1376d201456903f3ecae1f7794edfab0d5678e64226shiqian// The maximum number a BiggestInt can represent. This definition 1377d201456903f3ecae1f7794edfab0d5678e64226shiqian// works no matter BiggestInt is represented in one's complement or 1378d201456903f3ecae1f7794edfab0d5678e64226shiqian// two's complement. 1379d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1380d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot rely on numeric_limits in STL, as __int64 and long long 1381d201456903f3ecae1f7794edfab0d5678e64226shiqian// are not part of standard C++ and numeric_limits doesn't need to be 1382d201456903f3ecae1f7794edfab0d5678e64226shiqian// defined for them. 1383d201456903f3ecae1f7794edfab0d5678e64226shiqianconst BiggestInt kMaxBiggestInt = 1384d201456903f3ecae1f7794edfab0d5678e64226shiqian ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 1385d201456903f3ecae1f7794edfab0d5678e64226shiqian 1386d201456903f3ecae1f7794edfab0d5678e64226shiqian// This template class serves as a compile-time function from size to 1387d201456903f3ecae1f7794edfab0d5678e64226shiqian// type. It maps a size in bytes to a primitive type with that 1388d201456903f3ecae1f7794edfab0d5678e64226shiqian// size. e.g. 1389d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1390d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize<4>::UInt 1391d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1392d201456903f3ecae1f7794edfab0d5678e64226shiqian// is typedef-ed to be unsigned int (unsigned integer made up of 4 1393d201456903f3ecae1f7794edfab0d5678e64226shiqian// bytes). 1394d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1395d201456903f3ecae1f7794edfab0d5678e64226shiqian// Such functionality should belong to STL, but I cannot find it 1396d201456903f3ecae1f7794edfab0d5678e64226shiqian// there. 1397d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1398d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test uses this class in the implementation of floating-point 1399d201456903f3ecae1f7794edfab0d5678e64226shiqian// comparison. 1400d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1401d201456903f3ecae1f7794edfab0d5678e64226shiqian// For now it only handles UInt (unsigned int) as that's all Google Test 1402d201456903f3ecae1f7794edfab0d5678e64226shiqian// needs. Other types can be easily added in the future if need 1403d201456903f3ecae1f7794edfab0d5678e64226shiqian// arises. 1404d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <size_t size> 1405d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize { 1406d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 1407d201456903f3ecae1f7794edfab0d5678e64226shiqian // This prevents the user from using TypeWithSize<N> with incorrect 1408d201456903f3ecae1f7794edfab0d5678e64226shiqian // values of N. 1409d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef void UInt; 1410d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1411d201456903f3ecae1f7794edfab0d5678e64226shiqian 1412d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 4. 1413d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 1414d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<4> { 1415d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 1416d201456903f3ecae1f7794edfab0d5678e64226shiqian // unsigned int has size 4 in both gcc and MSVC. 1417d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1418d201456903f3ecae1f7794edfab0d5678e64226shiqian // As base/basictypes.h doesn't compile on Windows, we cannot use 1419d201456903f3ecae1f7794edfab0d5678e64226shiqian // uint32, uint64, and etc here. 1420d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef int Int; 1421d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned int UInt; 1422d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1423d201456903f3ecae1f7794edfab0d5678e64226shiqian 1424d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 8. 1425d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 1426d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<8> { 1427d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 14280af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 1429d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef __int64 Int; 1430d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned __int64 UInt; 1431d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1432d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef long long Int; // NOLINT 1433d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned long long UInt; // NOLINT 1434d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 1435d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1436d201456903f3ecae1f7794edfab0d5678e64226shiqian 1437d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types of known sizes. 1438d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::Int Int32; 1439d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::UInt UInt32; 1440d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int Int64; 1441d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::UInt UInt64; 1442d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 1443d201456903f3ecae1f7794edfab0d5678e64226shiqian 1444d201456903f3ecae1f7794edfab0d5678e64226shiqian// Utilities for command line flags and environment variables. 1445d201456903f3ecae1f7794edfab0d5678e64226shiqian 1446d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macro for referencing flags. 1447d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG(name) FLAGS_gtest_##name 1448d201456903f3ecae1f7794edfab0d5678e64226shiqian 1449d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for declaring flags. 145083589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 1451e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_int32_(name) \ 145283589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 1453e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_string_(name) \ 145483589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name) 1455d201456903f3ecae1f7794edfab0d5678e64226shiqian 1456d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for defining flags. 1457e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_bool_(name, default_val, doc) \ 145883589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan GTEST_API_ bool GTEST_FLAG(name) = (default_val) 1459e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_int32_(name, default_val, doc) \ 146083589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 1461e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_string_(name, default_val, doc) \ 146283589cca345d2f03d93b0555437aa480e0ed6699zhanyong.wan GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val) 1463d201456903f3ecae1f7794edfab0d5678e64226shiqian 1464d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses 'str' for a 32-bit signed integer. If successful, writes the result 1465d201456903f3ecae1f7794edfab0d5678e64226shiqian// to *value and returns true; otherwise leaves *value unchanged and returns 1466d201456903f3ecae1f7794edfab0d5678e64226shiqian// false. 1467d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(chandlerc): Find a better way to refactor flag and environment parsing 1468d201456903f3ecae1f7794edfab0d5678e64226shiqian// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 1469d201456903f3ecae1f7794edfab0d5678e64226shiqian// function. 1470d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32(const Message& src_text, const char* str, Int32* value); 1471d201456903f3ecae1f7794edfab0d5678e64226shiqian 1472d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses a bool/Int32/string from the environment variable 1473d201456903f3ecae1f7794edfab0d5678e64226shiqian// corresponding to the given Google Test flag. 1474d201456903f3ecae1f7794edfab0d5678e64226shiqianbool BoolFromGTestEnv(const char* flag, bool default_val); 14759f0824b0a61b50fd40e47da2387cd9b3f872ce47zhanyong.wanGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 1476d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* StringFromGTestEnv(const char* flag, const char* default_val); 1477d201456903f3ecae1f7794edfab0d5678e64226shiqian 1478d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 1479d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 1480d201456903f3ecae1f7794edfab0d5678e64226shiqian 1481d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1482