gtest-port.h revision cfcbc298cd91806e0e3417e03fce42bc4f1fa150
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. 69d201456903f3ecae1f7794edfab0d5678e64226shiqian 70d201456903f3ecae1f7794edfab0d5678e64226shiqian// This header defines the following utilities: 71d201456903f3ecae1f7794edfab0d5678e64226shiqian// 720af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating the current platform (defined to 1 if compiled on 730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the given platform; otherwise undefined): 740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_CYGWIN - Cygwin 750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_LINUX - Linux 760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_MAC - Mac OS X 770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SOLARIS - Sun Solaris 780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SYMBIAN - Symbian 79b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 80b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 81b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan// GTEST_OS_WINDOWS_MINGW - MinGW 8281e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_ZOS - z/OS 84d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// 85b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 86b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// most stable support. Since core members of the Google Test project 87b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// don't have access to other platforms, support for them may be less 88b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// stable. If you notice any problems on your platform, please notify 89b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// googletestframework@googlegroups.com (patches for fixing them are 90b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// even more welcome!). 91b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// 920af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Note that it is possible that none of the GTEST_OS_* macros are defined. 93d201456903f3ecae1f7794edfab0d5678e64226shiqian// 940af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating available Google Test features (defined to 1 if 950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the corresponding feature is supported; otherwise undefined): 960af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 970af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// tests) 980af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_DEATH_TEST - death tests 990af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_PARAM_TEST - value-parameterized tests 1000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST - typed tests 1010af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 1020af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 1030af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_SIMPLE_RE - our own simple regex is used; 104c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// the above two are mutually exclusive. 105d201456903f3ecae1f7794edfab0d5678e64226shiqian// 106d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for basic C++ coding: 107e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 1080da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 1090da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// variable don't have to be used. 1107b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// GTEST_DISALLOW_ASSIGN_ - disables operator=. 111e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 112e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 113d201456903f3ecae1f7794edfab0d5678e64226shiqian// 114d201456903f3ecae1f7794edfab0d5678e64226shiqian// Synchronization: 115d201456903f3ecae1f7794edfab0d5678e64226shiqian// Mutex, MutexLock, ThreadLocal, GetThreadCount() 116d201456903f3ecae1f7794edfab0d5678e64226shiqian// - synchronization primitives. 117e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 118e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// synchronization primitives have real implementations 119e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// and Google Test is thread-safe; or 0 otherwise. 120d201456903f3ecae1f7794edfab0d5678e64226shiqian// 121d201456903f3ecae1f7794edfab0d5678e64226shiqian// Template meta programming: 122d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 123d201456903f3ecae1f7794edfab0d5678e64226shiqian// 124d201456903f3ecae1f7794edfab0d5678e64226shiqian// Smart pointers: 125d201456903f3ecae1f7794edfab0d5678e64226shiqian// scoped_ptr - as in TR2. 126d201456903f3ecae1f7794edfab0d5678e64226shiqian// 127d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular expressions: 128d201456903f3ecae1f7794edfab0d5678e64226shiqian// RE - a simple regular expression class using the POSIX 129d201456903f3ecae1f7794edfab0d5678e64226shiqian// Extended Regular Expression syntax. Not available on 130d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows. 131d201456903f3ecae1f7794edfab0d5678e64226shiqian// 132d201456903f3ecae1f7794edfab0d5678e64226shiqian// Logging: 133e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_LOG_() - logs messages at the specified severity level. 134d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 135d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 136d201456903f3ecae1f7794edfab0d5678e64226shiqian// 137fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// Stdout and stderr capturing: 138fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// CaptureStdout() - starts capturing stdout. 139fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// GetCapturedStdout() - stops capturing stdout and returns the captured 140fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// string. 141d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr() - starts capturing stderr. 142d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr() - stops capturing stderr and returns the captured 143d201456903f3ecae1f7794edfab0d5678e64226shiqian// string. 144d201456903f3ecae1f7794edfab0d5678e64226shiqian// 145d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types: 146d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize - maps an integer to a int type. 147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32, UInt32, Int64, UInt64, TimeInMillis 148d201456903f3ecae1f7794edfab0d5678e64226shiqian// - integers of known sizes. 149d201456903f3ecae1f7794edfab0d5678e64226shiqian// BiggestInt - the biggest signed integer type. 150d201456903f3ecae1f7794edfab0d5678e64226shiqian// 151d201456903f3ecae1f7794edfab0d5678e64226shiqian// Command-line utilities: 152d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_FLAG() - references a flag. 153d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DECLARE_*() - declares a flag. 154d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DEFINE_*() - defines a flag. 155d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetArgvs() - returns the command line as a vector of strings. 156d201456903f3ecae1f7794edfab0d5678e64226shiqian// 157d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variable utilities: 158d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetEnv() - gets the value of an environment variable. 159d201456903f3ecae1f7794edfab0d5678e64226shiqian// BoolFromGTestEnv() - parses a bool environment variable. 160d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32FromGTestEnv() - parses an Int32 environment variable. 161d201456903f3ecae1f7794edfab0d5678e64226shiqian// StringFromGTestEnv() - parses a string environment variable. 162d201456903f3ecae1f7794edfab0d5678e64226shiqian 1634853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#include <stddef.h> // For ptrdiff_t 164d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 165d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdio.h> 1663c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <string.h> 1674853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1683c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/stat.h> 1694853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif // !_WIN32_WCE 1703c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1713c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <iostream> // NOLINT 1727b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#include <sstream> // NOLINT 1737b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#include <string> // NOLINT 174d201456903f3ecae1f7794edfab0d5678e64226shiqian 17587d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 1760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_ "gtest_" 1776bfc4b2bd378940fa006bd32b9667ad4137d8f15vladlosev#define GTEST_FLAG_PREFIX_DASH_ "gtest-" 1780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 17987d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_NAME_ "Google Test" 18087d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 181d201456903f3ecae1f7794edfab0d5678e64226shiqian 18264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines the version of gcc that is used to compile this. 18364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GNUC__ 18464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// 40302 means version 4.3.2. 18564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_GCC_VER_ \ 18664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 18764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ 18864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 189d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines the platform on which Google Test is compiled. 190e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#ifdef __CYGWIN__ 1910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_CYGWIN 1 192ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan#elif defined __SYMBIAN32__ 1930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SYMBIAN 1 1946a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#elif defined _WIN32 1950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_WINDOWS 1 196b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#ifdef _WIN32_WCE 197b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_MOBILE 1 198b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#elif defined(__MINGW__) || defined(__MINGW32__) 199b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_MINGW 1 200b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 201b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#define GTEST_OS_WINDOWS_DESKTOP 1 202b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // _WIN32_WCE 203d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __APPLE__ 2040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_MAC 1 205d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __linux__ 2060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_LINUX 1 207d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined __MVS__ 2080af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_ZOS 1 209d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined(__sun) && defined(__SVR4) 2100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SOLARIS 1 2116a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#endif // __CYGWIN__ 212d201456903f3ecae1f7794edfab0d5678e64226shiqian 2135502540a5b5c5378824cd46591c2366bcf027555chandlerc#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \ 2145502540a5b5c5378824cd46591c2366bcf027555chandlerc GTEST_OS_SOLARIS 215c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 216c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// On some platforms, <regex.h> needs someone to define size_t, and 217c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// won't compile otherwise. We can #include it here as we already 218c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// included <stdlib.h>, which is guaranteed to define size_t through 219c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// <stddef.h>. 220c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#include <regex.h> // NOLINT 2213c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <strings.h> // NOLINT 2223c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/types.h> // NOLINT 2233c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <unistd.h> // NOLINT 2243c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 225c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_POSIX_RE 1 226c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2273c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#elif GTEST_OS_WINDOWS 2283c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 229b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 2303c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <direct.h> // NOLINT 2313c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <io.h> // NOLINT 232b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif 2333c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 2343c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// <regex.h> is not available on Windows. Use our own simple regex 2353c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// implementation instead. 2363c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 2373c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 238c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else 239c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2404984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// <regex.h> may not be available on this platform. Use our own 2414984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// simple regex implementation instead. 242c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 243c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2445502540a5b5c5378824cd46591c2366bcf027555chandlerc#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || 2455502540a5b5c5378824cd46591c2366bcf027555chandlerc // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS 246c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 247cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#ifndef GTEST_HAS_EXCEPTIONS 248cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// The user didn't tell us whether exceptions are enabled, so we need 249cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// to figure it out. 250c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 251c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 252c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// macro to enable exceptions, so we'll do the same. 253d201456903f3ecae1f7794edfab0d5678e64226shiqian// Assumes that exceptions are enabled by default. 254c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef _HAS_EXCEPTIONS 255d201456903f3ecae1f7794edfab0d5678e64226shiqian#define _HAS_EXCEPTIONS 1 256d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // _HAS_EXCEPTIONS 257d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 258cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__GNUC__) && __EXCEPTIONS 259cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 260cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#define GTEST_HAS_EXCEPTIONS 1 261cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__SUNPRO_CC) 262cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Sun Pro CC supports exceptions. However, there is no compile-time way of 263cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// detecting whether they are enabled or not. Therefore, we assume that 264cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// they are enabled unless the user tells us otherwise. 2653c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 1 2663c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#else 267cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// For other compilers, we assume exceptions are disabled to be 268cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// conservative. 2693c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 0 270c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // defined(_MSC_VER) || defined(__BORLANDC__) 271cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif // GTEST_HAS_EXCEPTIONS 272d201456903f3ecae1f7794edfab0d5678e64226shiqian 27388e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#if !defined(GTEST_HAS_STD_STRING) 27488e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// Even though we don't use this macro any longer, we keep it in case 27588e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// some clients still depend on it. 2763c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_STD_STRING 1 27788e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#elif !GTEST_HAS_STD_STRING 27888e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// The user told us that ::std::string isn't available. 27988e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#error "Google Test cannot be used where ::std::string isn't available." 28088e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#endif // !defined(GTEST_HAS_STD_STRING) 281d201456903f3ecae1f7794edfab0d5678e64226shiqian 282d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_STRING 283d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::string is available, so we need 284d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 285d201456903f3ecae1f7794edfab0d5678e64226shiqian 286d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_GLOBAL_STRING 0 287d201456903f3ecae1f7794edfab0d5678e64226shiqian 288d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 289d201456903f3ecae1f7794edfab0d5678e64226shiqian 290d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_STD_WSTRING 291d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::std::wstring is available, so we need 292d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 293d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 294d201456903f3ecae1f7794edfab0d5678e64226shiqian// is available. 295d201456903f3ecae1f7794edfab0d5678e64226shiqian 296bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.5 and below doesn't support ::std::wstring. 297bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.7 might add wstring support; this should be updated when clear. 298d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Solaris' libc++ doesn't support it either. 29988e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 300d201456903f3ecae1f7794edfab0d5678e64226shiqian 301d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 302d201456903f3ecae1f7794edfab0d5678e64226shiqian 303d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_WSTRING 304d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::wstring is available, so we need 305d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 306bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan#define GTEST_HAS_GLOBAL_WSTRING \ 307bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 308d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 309d201456903f3ecae1f7794edfab0d5678e64226shiqian 31064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines whether RTTI is available. 31164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifndef GTEST_HAS_RTTI 31264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// The user didn't tell us whether RTTI is enabled, so we need to 31364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// figure it out. 31464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 31564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _MSC_VER 31664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 31764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 31864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 31964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 32064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 32164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // _CPPRTTI 32264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 32364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#elif defined(__GNUC__) 32464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 32564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 32664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if GTEST_GCC_VER_ >= 40302 32764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GXX_RTTI 32864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 32964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 33064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 33164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GXX_RTTI 33264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 33364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// For gcc versions smaller than 4.3.2, we assume RTTI is enabled. 33464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 33564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // GTEST_GCC_VER >= 40302 33664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 33864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Unknown compiler - assume RTTI is enabled. 34064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 34164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 34264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // _MSC_VER 34364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 34464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // GTEST_HAS_RTTI 34564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 346e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Determines whether <pthread.h> is available. 347e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#ifndef GTEST_HAS_PTHREAD 348e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The user didn't tell us, so we need to figure it out. 349cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SOLARIS) 350e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_HAS_PTHREAD 351e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 352532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// Determines whether Google Test can use tr1/tuple. You can define 353532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// this macro to 0 to prevent Google Test from using tuple (any 354532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// feature depending on tuple with be disabled in this mode). 3553d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#ifndef GTEST_HAS_TR1_TUPLE 356532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// The user didn't tell us not to do it, so we assume it's OK. 357532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_HAS_TR1_TUPLE 1 358532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_HAS_TR1_TUPLE 359532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan 360532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// Determines whether Google Test's own tr1 tuple implementation 361532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan// should be used. 362532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#ifndef GTEST_USE_OWN_TR1_TUPLE 3633d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// The user didn't tell us, so we need to figure it out. 3643d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 365fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// We use our own TR1 tuple if we aren't sure the user has an 366edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// implementation of it already. At this time, GCC 4.0.0+ and MSVC 367edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// 2010 are the only mainstream compilers that come with a TR1 tuple 368fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by 369fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// defining __GNUC__ and friends, but cannot compile GCC's tuple 370edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB 371edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan// Feature Pack download, which we cannot assume the user has. 372fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ 373fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan || _MSC_VER >= 1600 374532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_USE_OWN_TR1_TUPLE 0 3753d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else 376532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#define GTEST_USE_OWN_TR1_TUPLE 1 377edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#endif 378532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan 379532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_USE_OWN_TR1_TUPLE 3803d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 3815145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// To avoid conditional compilation everywhere, we make it 3825145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// gtest-port.h's responsibility to #include the header implementing 3835145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple. 3845145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if GTEST_HAS_TR1_TUPLE 385e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 386532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#if GTEST_USE_OWN_TR1_TUPLE 387532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#include <gtest/internal/gtest-tuple.h> 388532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#elif GTEST_OS_SYMBIAN 389e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 390e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 391e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// use STLport's tuple implementation, which unfortunately doesn't 392e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// work as the copy of STLport distributed with Symbian is incomplete. 393e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 394e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// use its own tuple implementation. 395e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#ifdef BOOST_HAS_TR1_TUPLE 396e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#undef BOOST_HAS_TR1_TUPLE 397e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#endif // BOOST_HAS_TR1_TUPLE 398e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 399e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// This prevents <boost/tr1/detail/config.hpp>, which defines 400e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 401e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 402e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#include <tuple> 403e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 404e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 4059b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 4069b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// not conform to the TR1 spec, which requires the header to be <tuple>. 407683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan 408683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 409683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 410683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// which is #included by <tr1/tuple>, to not compile when RTTI is 411683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// disabled. _TR1_FUNCTIONAL is the header guard for 412683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// <tr1/functional>. Hence the following #define is a hack to prevent 413683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan// <tr1/functional> from being included. 414683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#define _TR1_FUNCTIONAL 1 415683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#include <tr1/tuple> 416683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#undef _TR1_FUNCTIONAL // Allows the user to #include 417683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan // <tr1/functional> if he chooses to. 418683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#else 419edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#include <tr1/tuple> // NOLINT 420683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan#endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 421683f431d830dea27069e7eef11d355bae2b82b72zhanyong.wan 4225145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#else 4239b23e3cc7677643f6adaf6c327275d0a7cdff02czhanyong.wan// If the compiler is not GCC 4.0+, we assume the user is using a 4245145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// spec-conforming TR1 implementation. 425edbcd6294e399be1ec2400c33b9d3aa9f6dbbf85zhanyong.wan#include <tuple> // NOLINT 426532dc2de35f2cef191bc91c3587a9f8f4974756fzhanyong.wan#endif // GTEST_USE_OWN_TR1_TUPLE 427e68adf5c9089b4e2b7d527eb398471a7728b2939zhanyong.wan 4285145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif // GTEST_HAS_TR1_TUPLE 4295145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian 43004f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Determines whether clone(2) is supported. 43104f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Usually it will only be available on Linux, excluding 43204f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Linux on the Itanium architecture. 43304f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Also see http://linux.die.net/man/2/clone. 43404f025dd5746fca83c6c32f1729b3449721dd60eshiqian#ifndef GTEST_HAS_CLONE 43504f025dd5746fca83c6c32f1729b3449721dd60eshiqian// The user didn't tell us, so we need to figure it out. 43604f025dd5746fca83c6c32f1729b3449721dd60eshiqian 4370af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX && !defined(__ia64__) 43804f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 1 43904f025dd5746fca83c6c32f1729b3449721dd60eshiqian#else 44004f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 0 4410af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_LINUX && !defined(__ia64__) 44204f025dd5746fca83c6c32f1729b3449721dd60eshiqian 44304f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif // GTEST_HAS_CLONE 44404f025dd5746fca83c6c32f1729b3449721dd60eshiqian 44581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// Determines whether to support stream redirection. This is used to test 44681e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan// output correctness and to implement death tests. 44781e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 44881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#define GTEST_HAS_STREAM_REDIRECTION_ 1 44981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 45081e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 451d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines whether to support death tests. 45288e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// Google Test does not support death tests for VC 7.1 and earlier as 45388e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// abort() in a VC 7.1 application compiled as GUI in debug config 45488e97c822c988eaa9f8bcbaa1ea5d702ffd7d384zhanyong.wan// pops up a dialog window that cannot be suppressed programmatically. 455cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 456bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW) 4570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_DEATH_TEST 1 4583c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <vector> // NOLINT 4599623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan#endif 460d201456903f3ecae1f7794edfab0d5678e64226shiqian 4613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support value-parameterized tests. 4623d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 4633d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(__GNUC__) || (_MSC_VER >= 1400) 4643d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// TODO(vladl@google.com): get the implementation rid of vector and list 4653d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// to compile on MSVC 7.1. 4660af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_PARAM_TEST 1 4673d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 4683d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 469a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Determines whether to support type-driven tests. 470a2b1a8556ea64014606d78b09333d9c522430a25shiqian 471cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, and 472cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Sun Pro CC support. 473cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) 474c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST 1 475c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST_P 1 476cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif 477a2b1a8556ea64014606d78b09333d9c522430a25shiqian 4783d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support Combine(). This only makes sense when 4793d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// value-parameterized tests are enabled. 4800af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 4810af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_COMBINE 1 4820af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 4833d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 4840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Determines whether the system compiler uses UTF-16 for encoding wide strings. 4850af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_WIDE_STRING_USES_UTF16_ \ 4860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN) 4870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 488d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines some utility macros. 489d201456903f3ecae1f7794edfab0d5678e64226shiqian 490d201456903f3ecae1f7794edfab0d5678e64226shiqian// The GNU compiler emits a warning if nested "if" statements are followed by 491d201456903f3ecae1f7794edfab0d5678e64226shiqian// an "else" statement and braces are not used to explicitly disambiguate the 492d201456903f3ecae1f7794edfab0d5678e64226shiqian// "else" binding. This leads to problems with code like: 493d201456903f3ecae1f7794edfab0d5678e64226shiqian// 494d201456903f3ecae1f7794edfab0d5678e64226shiqian// if (gate) 495d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_*(condition) << "Some message"; 496d201456903f3ecae1f7794edfab0d5678e64226shiqian// 497d201456903f3ecae1f7794edfab0d5678e64226shiqian// The "switch (0) case 0:" idiom is used to suppress this. 498d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __INTEL_COMPILER 499e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 500d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 501e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 502d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 503d201456903f3ecae1f7794edfab0d5678e64226shiqian 5040da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Use this annotation at the end of a struct/class definition to 505d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent the compiler from optimizing away instances that are never 506d201456903f3ecae1f7794edfab0d5678e64226shiqian// used. This is useful when all interesting logic happens inside the 507d201456903f3ecae1f7794edfab0d5678e64226shiqian// c'tor and / or d'tor. Example: 508d201456903f3ecae1f7794edfab0d5678e64226shiqian// 509d201456903f3ecae1f7794edfab0d5678e64226shiqian// struct Foo { 510d201456903f3ecae1f7794edfab0d5678e64226shiqian// Foo() { ... } 511e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// } GTEST_ATTRIBUTE_UNUSED_; 5120da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// 5130da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Also use it after a variable or parameter declaration to tell the 5140da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// compiler the variable/parameter does not have to be used. 515bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#if defined(__GNUC__) && !defined(COMPILER_ICC) 516e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 517bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#else 518e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ 519bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#endif 520d201456903f3ecae1f7794edfab0d5678e64226shiqian 5217b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// A macro to disallow operator= 5227b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// This should be used in the private: declarations for a class. 5237b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan#define GTEST_DISALLOW_ASSIGN_(type)\ 5247b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan void operator=(type const &) 5257b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan 5267b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan// A macro to disallow copy constructor and operator= 527d201456903f3ecae1f7794edfab0d5678e64226shiqian// This should be used in the private: declarations for a class. 528e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 5297b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan type(type const &);\ 5307b0c8dd3a94fed17493e2f01dc2fa32bc1eb3a20zhanyong.wan GTEST_DISALLOW_ASSIGN_(type) 531d201456903f3ecae1f7794edfab0d5678e64226shiqian 532d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tell the compiler to warn about unused return values for functions declared 533d201456903f3ecae1f7794edfab0d5678e64226shiqian// with this macro. The macro should be used on function declarations 534d201456903f3ecae1f7794edfab0d5678e64226shiqian// following the argument list: 535d201456903f3ecae1f7794edfab0d5678e64226shiqian// 536e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 53764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 538e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 539d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 540e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ 54164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 542d201456903f3ecae1f7794edfab0d5678e64226shiqian 543f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Determine whether the compiler supports Microsoft's Structured Exception 544f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Handling. This is supported by several Windows compilers but generally 545f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// does not exist on any other system. 546f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#ifndef GTEST_HAS_SEH 547f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// The user didn't tell us, so we need to figure it out. 548f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 549f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 550f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// These two compilers are known to support SEH. 551f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 1 552f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#else 553f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Assume no SEH. 554f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 0 555f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif 556f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 557f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif // GTEST_HAS_SEH 558f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 559d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 560d201456903f3ecae1f7794edfab0d5678e64226shiqian 561d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message; 562d201456903f3ecae1f7794edfab0d5678e64226shiqian 563d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 564d201456903f3ecae1f7794edfab0d5678e64226shiqian 565d201456903f3ecae1f7794edfab0d5678e64226shiqianclass String; 566d201456903f3ecae1f7794edfab0d5678e64226shiqian 567d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::stringstream StrStream; 568d201456903f3ecae1f7794edfab0d5678e64226shiqian 569f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// A helper for suppressing warnings on constant condition. It just 570f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// returns 'condition'. 571f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanbool IsTrue(bool condition); 572f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan 573d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines scoped_ptr. 574d201456903f3ecae1f7794edfab0d5678e64226shiqian 575d201456903f3ecae1f7794edfab0d5678e64226shiqian// This implementation of scoped_ptr is PARTIAL - it only contains 576d201456903f3ecae1f7794edfab0d5678e64226shiqian// enough stuff to satisfy Google Test's need. 577d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 578d201456903f3ecae1f7794edfab0d5678e64226shiqianclass scoped_ptr { 579d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 580b6fe6899bef6dd90572fc0e7f12912d9ad87a19evladlosev typedef T element_type; 581b6fe6899bef6dd90572fc0e7f12912d9ad87a19evladlosev 582d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 583d201456903f3ecae1f7794edfab0d5678e64226shiqian ~scoped_ptr() { reset(); } 584d201456903f3ecae1f7794edfab0d5678e64226shiqian 585d201456903f3ecae1f7794edfab0d5678e64226shiqian T& operator*() const { return *ptr_; } 586d201456903f3ecae1f7794edfab0d5678e64226shiqian T* operator->() const { return ptr_; } 587d201456903f3ecae1f7794edfab0d5678e64226shiqian T* get() const { return ptr_; } 588d201456903f3ecae1f7794edfab0d5678e64226shiqian 589d201456903f3ecae1f7794edfab0d5678e64226shiqian T* release() { 590d201456903f3ecae1f7794edfab0d5678e64226shiqian T* const ptr = ptr_; 591d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = NULL; 592d201456903f3ecae1f7794edfab0d5678e64226shiqian return ptr; 593d201456903f3ecae1f7794edfab0d5678e64226shiqian } 594d201456903f3ecae1f7794edfab0d5678e64226shiqian 595d201456903f3ecae1f7794edfab0d5678e64226shiqian void reset(T* p = NULL) { 596d201456903f3ecae1f7794edfab0d5678e64226shiqian if (p != ptr_) { 597f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 598d201456903f3ecae1f7794edfab0d5678e64226shiqian delete ptr_; 599d201456903f3ecae1f7794edfab0d5678e64226shiqian } 600d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = p; 601d201456903f3ecae1f7794edfab0d5678e64226shiqian } 602d201456903f3ecae1f7794edfab0d5678e64226shiqian } 603d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 604d201456903f3ecae1f7794edfab0d5678e64226shiqian T* ptr_; 605d201456903f3ecae1f7794edfab0d5678e64226shiqian 606e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 607d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 608d201456903f3ecae1f7794edfab0d5678e64226shiqian 6093d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Defines RE. 610d201456903f3ecae1f7794edfab0d5678e64226shiqian 611d201456903f3ecae1f7794edfab0d5678e64226shiqian// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended 612d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular Expression syntax. 613d201456903f3ecae1f7794edfab0d5678e64226shiqianclass RE { 614d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 615d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs an RE from a string. 616d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 617d201456903f3ecae1f7794edfab0d5678e64226shiqian 618d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 619d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 620d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 621d201456903f3ecae1f7794edfab0d5678e64226shiqian 622d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const char* regex) { Init(regex); } // NOLINT 623d201456903f3ecae1f7794edfab0d5678e64226shiqian ~RE(); 624d201456903f3ecae1f7794edfab0d5678e64226shiqian 625d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the string representation of the regex. 626d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern() const { return pattern_; } 627d201456903f3ecae1f7794edfab0d5678e64226shiqian 6283d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // FullMatch(str, re) returns true iff regular expression re matches 6293d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // the entire str. 6303d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // PartialMatch(str, re) returns true iff regular expression re 6313d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // matches a substring of str (including str itself). 6323d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // 6333d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // TODO(wan@google.com): make FullMatch() and PartialMatch() work 6343d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // when str contains NUL characters. 6353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::std::string& str, const RE& re) { 6363d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 6373d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 638d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::std::string& str, const RE& re) { 639d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 640d201456903f3ecae1f7794edfab0d5678e64226shiqian } 641d201456903f3ecae1f7794edfab0d5678e64226shiqian 642d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 6433d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::string& str, const RE& re) { 6443d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 6453d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 646d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::string& str, const RE& re) { 647d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 648d201456903f3ecae1f7794edfab0d5678e64226shiqian } 649d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 650d201456903f3ecae1f7794edfab0d5678e64226shiqian 6513d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const char* str, const RE& re); 652d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const char* str, const RE& re); 653d201456903f3ecae1f7794edfab0d5678e64226shiqian 654d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 655d201456903f3ecae1f7794edfab0d5678e64226shiqian void Init(const char* regex); 656d201456903f3ecae1f7794edfab0d5678e64226shiqian 657d201456903f3ecae1f7794edfab0d5678e64226shiqian // We use a const char* instead of a string, as Google Test may be used 658d201456903f3ecae1f7794edfab0d5678e64226shiqian // where string is not available. We also do not use Google Test's own 659d201456903f3ecae1f7794edfab0d5678e64226shiqian // String type here, in order to simplify dependencies between the 660d201456903f3ecae1f7794edfab0d5678e64226shiqian // files. 661d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern_; 662c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan bool is_valid_; 663c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#if GTEST_USES_POSIX_RE 6643d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t full_regex_; // For FullMatch(). 6653d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t partial_regex_; // For PartialMatch(). 666c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else // GTEST_USES_SIMPLE_RE 667c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan const char* full_pattern_; // For FullMatch(); 668c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#endif 669d201456903f3ecae1f7794edfab0d5678e64226shiqian 670c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(RE); 671c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan}; 672d201456903f3ecae1f7794edfab0d5678e64226shiqian 673d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines logging utilities: 674866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// GTEST_LOG_(severity) - logs messages at the specified severity level. The 675866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// message itself is streamed into the macro. 676d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 677d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 678d201456903f3ecae1f7794edfab0d5678e64226shiqian 679d201456903f3ecae1f7794edfab0d5678e64226shiqianenum GTestLogSeverity { 680d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_INFO, 681d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_WARNING, 682d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_ERROR, 683d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FATAL 684d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 685d201456903f3ecae1f7794edfab0d5678e64226shiqian 686866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// Formats log entry severity, provides a stream object for streaming the 687866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// log message, and terminates the message with a newline when going out of 688866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan// scope. 689866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wanclass GTestLog { 690866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan public: 691866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan GTestLog(GTestLogSeverity severity, const char* file, int line); 692866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 693866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 694866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ~GTestLog(); 695866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 696866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ::std::ostream& GetStream() { return ::std::cerr; } 697866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 698866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan private: 699866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan const GTestLogSeverity severity_; 700866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan 701866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 702866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan}; 703d201456903f3ecae1f7794edfab0d5678e64226shiqian 704866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan#define GTEST_LOG_(severity) \ 705866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 706866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan __FILE__, __LINE__).GetStream() 707d201456903f3ecae1f7794edfab0d5678e64226shiqian 708d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void LogToStderr() {} 709d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void FlushInfoLog() { fflush(NULL); } 710d201456903f3ecae1f7794edfab0d5678e64226shiqian 71181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION_ 712fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 713d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines the stderr capturer: 714fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// CaptureStdout - starts capturing stdout. 715fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// GetCapturedStdout - stops capturing stdout and returns the captured string. 716d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr - starts capturing stderr. 717d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr - stops capturing stderr and returns the captured string. 718fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan// 719fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wanvoid CaptureStdout(); 720fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wanString GetCapturedStdout(); 7214984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanvoid CaptureStderr(); 722ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wanString GetCapturedStderr(); 7234984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 72481e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan#endif // GTEST_HAS_STREAM_REDIRECTION_ 725fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 726fd6f2a8a4b3fe8beb31f26b774b460727c410b66zhanyong.wan 7270af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 728d201456903f3ecae1f7794edfab0d5678e64226shiqian 729d201456903f3ecae1f7794edfab0d5678e64226shiqian// A copy of all command line arguments. Set by InitGoogleTest(). 730d201456903f3ecae1f7794edfab0d5678e64226shiqianextern ::std::vector<String> g_argvs; 731d201456903f3ecae1f7794edfab0d5678e64226shiqian 732d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_DEATH_TEST implies we have ::std::string. 733d201456903f3ecae1f7794edfab0d5678e64226shiqianconst ::std::vector<String>& GetArgvs(); 734d201456903f3ecae1f7794edfab0d5678e64226shiqian 735d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_DEATH_TEST 736d201456903f3ecae1f7794edfab0d5678e64226shiqian 737d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines synchronization primitives. 738d201456903f3ecae1f7794edfab0d5678e64226shiqian 739d201456903f3ecae1f7794edfab0d5678e64226shiqian// A dummy implementation of synchronization primitives (mutex, lock, 740d201456903f3ecae1f7794edfab0d5678e64226shiqian// and thread-local variable). Necessary for compiling Google Test where 741d201456903f3ecae1f7794edfab0d5678e64226shiqian// mutex is not supported - using Google Test in multiple threads is not 742d201456903f3ecae1f7794edfab0d5678e64226shiqian// supported on such platforms. 743d201456903f3ecae1f7794edfab0d5678e64226shiqian 744d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Mutex { 745d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 746d201456903f3ecae1f7794edfab0d5678e64226shiqian Mutex() {} 747b75872639683cf572253f20863982324b113205eshiqian explicit Mutex(int /*unused*/) {} 748d201456903f3ecae1f7794edfab0d5678e64226shiqian void AssertHeld() const {} 749d201456903f3ecae1f7794edfab0d5678e64226shiqian enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 }; 750d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 751d201456903f3ecae1f7794edfab0d5678e64226shiqian 752d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot call it MutexLock directly as the ctor declaration would 753d201456903f3ecae1f7794edfab0d5678e64226shiqian// conflict with a macro named MutexLock, which is defined on some 754d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms. Hence the typedef trick below. 755d201456903f3ecae1f7794edfab0d5678e64226shiqianclass GTestMutexLock { 756d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 757d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit GTestMutexLock(Mutex*) {} // NOLINT 758d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 759d201456903f3ecae1f7794edfab0d5678e64226shiqian 760d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef GTestMutexLock MutexLock; 761d201456903f3ecae1f7794edfab0d5678e64226shiqian 762d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 763d201456903f3ecae1f7794edfab0d5678e64226shiqianclass ThreadLocal { 764d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 765e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal() : value_() {} 766e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian explicit ThreadLocal(const T& value) : value_(value) {} 767d201456903f3ecae1f7794edfab0d5678e64226shiqian T* pointer() { return &value_; } 768d201456903f3ecae1f7794edfab0d5678e64226shiqian const T* pointer() const { return &value_; } 769d201456903f3ecae1f7794edfab0d5678e64226shiqian const T& get() const { return value_; } 770d201456903f3ecae1f7794edfab0d5678e64226shiqian void set(const T& value) { value_ = value; } 771d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 772d201456903f3ecae1f7794edfab0d5678e64226shiqian T value_; 773d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 774d201456903f3ecae1f7794edfab0d5678e64226shiqian 775c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// Returns the number of threads running in the process, or 0 to indicate that 776c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// we cannot detect it. 777c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wansize_t GetThreadCount(); 778d201456903f3ecae1f7794edfab0d5678e64226shiqian 779e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The above synchronization primitives have dummy implementations. 780e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Therefore Google Test is not thread-safe. 781e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_IS_THREADSAFE 0 782e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 783d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Passing non-POD classes through ellipsis (...) crashes the ARM 78444bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// compiler and generates a warning in Sun Studio. The Nokia Symbian 78544bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// and the IBM XL C/C++ compiler try to instantiate a copy constructor 78644bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// for objects passed through ellipsis (...), failing for uncopyable 78744bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// objects. We define this to ensure that only POD is passed through 78844bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan// ellipsis on these systems. 78944bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 79044bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#define GTEST_ELLIPSIS_NEEDS_POD_ 1 79144bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#endif 792d201456903f3ecae1f7794edfab0d5678e64226shiqian 793d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 794d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// const T& and const T* in a function template. These compilers 795d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// _can_ decide between class template specializations for T and T*, 796d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// so a tr1::type_traits-like is_pointer works. 79744bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 798d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_NEEDS_IS_POINTER_ 1 79944bafcb62d0f33fbc9aafb5492b245c949850df8zhanyong.wan#endif 800d201456903f3ecae1f7794edfab0d5678e64226shiqian 801d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> 802d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct bool_constant { 803d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef bool_constant<bool_value> type; 804d201456903f3ecae1f7794edfab0d5678e64226shiqian static const bool value = bool_value; 805d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 806d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> const bool bool_constant<bool_value>::value; 807d201456903f3ecae1f7794edfab0d5678e64226shiqian 808d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<false> false_type; 809d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<true> true_type; 810d201456903f3ecae1f7794edfab0d5678e64226shiqian 811d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 812d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer : public false_type {}; 813d201456903f3ecae1f7794edfab0d5678e64226shiqian 814d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 815d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer<T*> : public true_type {}; 816d201456903f3ecae1f7794edfab0d5678e64226shiqian 81787d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#if GTEST_OS_WINDOWS 81887d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "\\" 8198d373310561a8d68d2a22ca7c6613deff5fa6e05zhanyong.wan#define GTEST_HAS_ALT_PATH_SEP_ 1 8203c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The biggest signed integer type the compiler supports. 8213c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef __int64 BiggestInt; 82287d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#else 82387d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "/" 8248d373310561a8d68d2a22ca7c6613deff5fa6e05zhanyong.wan#define GTEST_HAS_ALT_PATH_SEP_ 0 8253c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef long long BiggestInt; // NOLINT 82687d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#endif // GTEST_OS_WINDOWS 82787d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan 8283c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The testing::internal::posix namespace holds wrappers for common 8293c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// POSIX functions. These wrappers hide the differences between 830f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// Windows/MSVC and POSIX systems. Since some compilers define these 831f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// standard functions as macros, the wrapper cannot have the same name 832f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// as the wrapped function. 833f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan 8343c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wannamespace posix { 8353c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8363c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions with a different name on Windows. 8373c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8380af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 8393c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 840f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct _stat StatStruct; 8413c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 842c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 843c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 844c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 845c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return stricmp(s1, s2); 846c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 847c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 8484853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#else // !__BORLANDC__ 849b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 8504853a503371f39aa22e14adcdecea71c09841e34zhanyong.waninline int IsATTY(int /* fd */) { return 0; } 851b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 852f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return _isatty(fd); } 853b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 854f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 855f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return _stricmp(s1, s2); 8563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 857f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline char* StrDup(const char* src) { return _strdup(src); } 858c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // __BORLANDC__ 859c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 860b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 8614853a503371f39aa22e14adcdecea71c09841e34zhanyong.waninline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 8624853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 8634853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// time and thus not defined there. 864b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#else 865c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int FileNo(FILE* file) { return _fileno(file); } 866c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 867f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return _rmdir(dir); } 868f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { 8693c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return (_S_IFDIR & st.st_mode) != 0; 8703c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 871b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 8723c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 873d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 8743c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 875f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct stat StatStruct; 8763c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 877f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FileNo(FILE* file) { return fileno(file); } 878f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 879f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 880f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 881f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strcasecmp(s1, s2); 882f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan} 883c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 884f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return rmdir(dir); } 885f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 8863c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 887d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 888d201456903f3ecae1f7794edfab0d5678e64226shiqian 8893c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions deprecated by MSVC 8.0. 8903c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8913c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 8923c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Temporarily disable warning 4996 (deprecated function). 8933c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(push) 8943c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(disable:4996) 8953c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 8963c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 897f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrNCpy(char* dest, const char* src, size_t n) { 898f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strncpy(dest, src, n); 8993c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 9004853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan 9014853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 9024853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// StrError() aren't needed on Windows CE at this time and thus not 9034853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// defined there. 9044853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan 905b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 906f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int ChDir(const char* dir) { return chdir(dir); } 9074853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 908f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FOpen(const char* path, const char* mode) { 909f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return fopen(path, mode); 9103c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 911b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 912f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 913f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return freopen(path, mode, stream); 9143c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 915f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 9164853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 917f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FClose(FILE* fp) { return fclose(fp); } 918b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 919f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Read(int fd, void* buf, unsigned int count) { 920f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(read(fd, buf, count)); 9213c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 922f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Write(int fd, const void* buf, unsigned int count) { 923f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(write(fd, buf, count)); 9243c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 925f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Close(int fd) { return close(fd); } 926f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrError(int errnum) { return strerror(errnum); } 9274853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif 928f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* GetEnv(const char* name) { 929b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 930b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan // We are on Windows CE, which has no environment variables. 9313c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return NULL; 932cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 933c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Environment variables which we programmatically clear will be set to the 934c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // empty string rather than unset (NULL). Handle that case. 935c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const char* const env = getenv(name); 936c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return (env != NULL && env[0] != '\0') ? env : NULL; 9373c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 938f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return getenv(name); 9393c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 9403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 9413c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 9423c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 9433c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(pop) // Restores the warning state. 9443c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 9453c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 946b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 9473c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Windows CE has no C library. The abort() function is used in 9483c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// several places in Google Test. This implementation provides a reasonable 9493c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// imitation of standard behaviour. 950f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wanvoid Abort(); 9513c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 952f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline void Abort() { abort(); } 953b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 9543c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 9553c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} // namespace posix 9563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 957d201456903f3ecae1f7794edfab0d5678e64226shiqian// The maximum number a BiggestInt can represent. This definition 958d201456903f3ecae1f7794edfab0d5678e64226shiqian// works no matter BiggestInt is represented in one's complement or 959d201456903f3ecae1f7794edfab0d5678e64226shiqian// two's complement. 960d201456903f3ecae1f7794edfab0d5678e64226shiqian// 961d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot rely on numeric_limits in STL, as __int64 and long long 962d201456903f3ecae1f7794edfab0d5678e64226shiqian// are not part of standard C++ and numeric_limits doesn't need to be 963d201456903f3ecae1f7794edfab0d5678e64226shiqian// defined for them. 964d201456903f3ecae1f7794edfab0d5678e64226shiqianconst BiggestInt kMaxBiggestInt = 965d201456903f3ecae1f7794edfab0d5678e64226shiqian ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 966d201456903f3ecae1f7794edfab0d5678e64226shiqian 967d201456903f3ecae1f7794edfab0d5678e64226shiqian// This template class serves as a compile-time function from size to 968d201456903f3ecae1f7794edfab0d5678e64226shiqian// type. It maps a size in bytes to a primitive type with that 969d201456903f3ecae1f7794edfab0d5678e64226shiqian// size. e.g. 970d201456903f3ecae1f7794edfab0d5678e64226shiqian// 971d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize<4>::UInt 972d201456903f3ecae1f7794edfab0d5678e64226shiqian// 973d201456903f3ecae1f7794edfab0d5678e64226shiqian// is typedef-ed to be unsigned int (unsigned integer made up of 4 974d201456903f3ecae1f7794edfab0d5678e64226shiqian// bytes). 975d201456903f3ecae1f7794edfab0d5678e64226shiqian// 976d201456903f3ecae1f7794edfab0d5678e64226shiqian// Such functionality should belong to STL, but I cannot find it 977d201456903f3ecae1f7794edfab0d5678e64226shiqian// there. 978d201456903f3ecae1f7794edfab0d5678e64226shiqian// 979d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test uses this class in the implementation of floating-point 980d201456903f3ecae1f7794edfab0d5678e64226shiqian// comparison. 981d201456903f3ecae1f7794edfab0d5678e64226shiqian// 982d201456903f3ecae1f7794edfab0d5678e64226shiqian// For now it only handles UInt (unsigned int) as that's all Google Test 983d201456903f3ecae1f7794edfab0d5678e64226shiqian// needs. Other types can be easily added in the future if need 984d201456903f3ecae1f7794edfab0d5678e64226shiqian// arises. 985d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <size_t size> 986d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize { 987d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 988d201456903f3ecae1f7794edfab0d5678e64226shiqian // This prevents the user from using TypeWithSize<N> with incorrect 989d201456903f3ecae1f7794edfab0d5678e64226shiqian // values of N. 990d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef void UInt; 991d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 992d201456903f3ecae1f7794edfab0d5678e64226shiqian 993d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 4. 994d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 995d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<4> { 996d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 997d201456903f3ecae1f7794edfab0d5678e64226shiqian // unsigned int has size 4 in both gcc and MSVC. 998d201456903f3ecae1f7794edfab0d5678e64226shiqian // 999d201456903f3ecae1f7794edfab0d5678e64226shiqian // As base/basictypes.h doesn't compile on Windows, we cannot use 1000d201456903f3ecae1f7794edfab0d5678e64226shiqian // uint32, uint64, and etc here. 1001d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef int Int; 1002d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned int UInt; 1003d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1004d201456903f3ecae1f7794edfab0d5678e64226shiqian 1005d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 8. 1006d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 1007d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<8> { 1008d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 10090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 1010d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef __int64 Int; 1011d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned __int64 UInt; 1012d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1013d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef long long Int; // NOLINT 1014d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned long long UInt; // NOLINT 1015d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 1016d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1017d201456903f3ecae1f7794edfab0d5678e64226shiqian 1018d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types of known sizes. 1019d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::Int Int32; 1020d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::UInt UInt32; 1021d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int Int64; 1022d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::UInt UInt64; 1023d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 1024d201456903f3ecae1f7794edfab0d5678e64226shiqian 1025d201456903f3ecae1f7794edfab0d5678e64226shiqian// Utilities for command line flags and environment variables. 1026d201456903f3ecae1f7794edfab0d5678e64226shiqian 10273d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// INTERNAL IMPLEMENTATION - DO NOT USE. 10283d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// 10293d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 10303d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// is not satisfied. 10313d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Synopsys: 10323d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_(boolean_condition); 10333d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// or 10343d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_(boolean_condition) << "Additional message"; 10353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// 10363d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// This checks the condition and if the condition is not satisfied 10373d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// it prints message about the condition violation, including the 10383d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// condition itself, plus additional message streamed into it, if any, 10393d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// and then it aborts the program. It aborts the program irrespective of 10403d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// whether it is built in the debug mode or not. 10413d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_CHECK_(condition) \ 10423d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1043f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (::testing::internal::IsTrue(condition)) \ 10443d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ; \ 10453d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev else \ 1046866f4a94461d765f7f9514b6cb6e82d7b9ea12d2zhanyong.wan GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 10473d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 1048d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macro for referencing flags. 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG(name) FLAGS_gtest_##name 1050d201456903f3ecae1f7794edfab0d5678e64226shiqian 1051d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for declaring flags. 1052e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name) 1053e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_int32_(name) \ 1054d201456903f3ecae1f7794edfab0d5678e64226shiqian extern ::testing::internal::Int32 GTEST_FLAG(name) 1055e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_string_(name) \ 1056d201456903f3ecae1f7794edfab0d5678e64226shiqian extern ::testing::internal::String GTEST_FLAG(name) 1057d201456903f3ecae1f7794edfab0d5678e64226shiqian 1058d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for defining flags. 1059e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_bool_(name, default_val, doc) \ 1060d201456903f3ecae1f7794edfab0d5678e64226shiqian bool GTEST_FLAG(name) = (default_val) 1061e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_int32_(name, default_val, doc) \ 1062d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 1063e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_string_(name, default_val, doc) \ 1064d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::String GTEST_FLAG(name) = (default_val) 1065d201456903f3ecae1f7794edfab0d5678e64226shiqian 1066d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses 'str' for a 32-bit signed integer. If successful, writes the result 1067d201456903f3ecae1f7794edfab0d5678e64226shiqian// to *value and returns true; otherwise leaves *value unchanged and returns 1068d201456903f3ecae1f7794edfab0d5678e64226shiqian// false. 1069d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(chandlerc): Find a better way to refactor flag and environment parsing 1070d201456903f3ecae1f7794edfab0d5678e64226shiqian// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian// function. 1072d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32(const Message& src_text, const char* str, Int32* value); 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian 1074d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses a bool/Int32/string from the environment variable 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian// corresponding to the given Google Test flag. 1076d201456903f3ecae1f7794edfab0d5678e64226shiqianbool BoolFromGTestEnv(const char* flag, bool default_val); 1077d201456903f3ecae1f7794edfab0d5678e64226shiqianInt32 Int32FromGTestEnv(const char* flag, Int32 default_val); 1078d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* StringFromGTestEnv(const char* flag, const char* default_val); 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian 1080d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 1081d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 1082d201456903f3ecae1f7794edfab0d5678e64226shiqian 1083d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1084