gtest-port.h revision c78ae6196dc9c24380b5cf86f8fd75a4d3edc704
1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc. 2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved. 3d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without 5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are 6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met: 7d201456903f3ecae1f7794edfab0d5678e64226shiqian// 8d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions of source code must retain the above copyright 9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer. 10d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions in binary form must reproduce the above 11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer 12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the 13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution. 14d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Neither the name of Google Inc. nor the names of its 15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from 16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission. 17d201456903f3ecae1f7794edfab0d5678e64226shiqian// 18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29d201456903f3ecae1f7794edfab0d5678e64226shiqian// 30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Authors: wan@google.com (Zhanyong Wan) 31d201456903f3ecae1f7794edfab0d5678e64226shiqian// 32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Low-level types and utilities for porting Google Test to various 33d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms. They are subject to change without notice. DO NOT USE 34d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEM IN USER CODE. 35d201456903f3ecae1f7794edfab0d5678e64226shiqian 36d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 37d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 38d201456903f3ecae1f7794edfab0d5678e64226shiqian 39d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user can define the following macros in the build script to 40e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// control Google Test's behavior. If the user doesn't define a macro 41e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// in this list, Google Test will define it. 42d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4304f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 4404f025dd5746fca83c6c32f1729b3449721dd60eshiqian// is/isn't available. 45d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 46d201456903f3ecae1f7794edfab0d5678e64226shiqian// is/isn't available (some systems define 47d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::string, which is different to std::string). 48d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 49d201456903f3ecae1f7794edfab0d5678e64226shiqian// is/isn't available (some systems define 50d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::wstring, which is different to std::wstring). 51e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 52e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// is/isn't available. 5304f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 5404f025dd5746fca83c6c32f1729b3449721dd60eshiqian// enabled. 5504f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_STD_STRING - Define it to 1/0 to indicate that 5604f025dd5746fca83c6c32f1729b3449721dd60eshiqian// std::string does/doesn't work (Google Test can 5704f025dd5746fca83c6c32f1729b3449721dd60eshiqian// be used where std::string is unavailable). 5804f025dd5746fca83c6c32f1729b3449721dd60eshiqian// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 5904f025dd5746fca83c6c32f1729b3449721dd60eshiqian// std::wstring does/doesn't work (Google Test can 6004f025dd5746fca83c6c32f1729b3449721dd60eshiqian// be used where std::wstring is unavailable). 613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_HAS_TR1_TUPLE 1 - Define it to 1/0 to indicate tr1::tuple 623d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// is/isn't available. 63f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 64f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// compiler supports Microsoft's "Structured 65f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Exception Handling". 66d201456903f3ecae1f7794edfab0d5678e64226shiqian 67d201456903f3ecae1f7794edfab0d5678e64226shiqian// This header defines the following utilities: 68d201456903f3ecae1f7794edfab0d5678e64226shiqian// 690af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating the current platform (defined to 1 if compiled on 700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the given platform; otherwise undefined): 710af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_CYGWIN - Cygwin 720af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_LINUX - Linux 730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_MAC - Mac OS X 740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SOLARIS - Sun Solaris 750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_SYMBIAN - Symbian 760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_WINDOWS - Windows 770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_OS_ZOS - z/OS 78d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// 79b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 80b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// most stable support. Since core members of the Google Test project 81b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// don't have access to other platforms, support for them may be less 82b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// stable. If you notice any problems on your platform, please notify 83b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// googletestframework@googlegroups.com (patches for fixing them are 84b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// even more welcome!). 85b6a296d0f7caff7140f422e49f5398c9ef17504dshiqian// 860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Note that it is possible that none of the GTEST_OS_* macros are defined. 87d201456903f3ecae1f7794edfab0d5678e64226shiqian// 880af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// Macros indicating available Google Test features (defined to 1 if 890af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// the corresponding feature is supported; otherwise undefined): 900af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// tests) 920af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_DEATH_TEST - death tests 930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_PARAM_TEST - value-parameterized tests 940af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST - typed tests 950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 960af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 970af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan// GTEST_USES_SIMPLE_RE - our own simple regex is used; 98c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// the above two are mutually exclusive. 99d201456903f3ecae1f7794edfab0d5678e64226shiqian// 100d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for basic C++ coding: 101e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 1020da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 1030da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// variable don't have to be used. 104e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 105e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 106d201456903f3ecae1f7794edfab0d5678e64226shiqian// 107d201456903f3ecae1f7794edfab0d5678e64226shiqian// Synchronization: 108d201456903f3ecae1f7794edfab0d5678e64226shiqian// Mutex, MutexLock, ThreadLocal, GetThreadCount() 109d201456903f3ecae1f7794edfab0d5678e64226shiqian// - synchronization primitives. 110e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 111e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// synchronization primitives have real implementations 112e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// and Google Test is thread-safe; or 0 otherwise. 113d201456903f3ecae1f7794edfab0d5678e64226shiqian// 114d201456903f3ecae1f7794edfab0d5678e64226shiqian// Template meta programming: 115d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 116d201456903f3ecae1f7794edfab0d5678e64226shiqian// 117d201456903f3ecae1f7794edfab0d5678e64226shiqian// Smart pointers: 118d201456903f3ecae1f7794edfab0d5678e64226shiqian// scoped_ptr - as in TR2. 119d201456903f3ecae1f7794edfab0d5678e64226shiqian// 120d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular expressions: 121d201456903f3ecae1f7794edfab0d5678e64226shiqian// RE - a simple regular expression class using the POSIX 122d201456903f3ecae1f7794edfab0d5678e64226shiqian// Extended Regular Expression syntax. Not available on 123d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows. 124d201456903f3ecae1f7794edfab0d5678e64226shiqian// 125d201456903f3ecae1f7794edfab0d5678e64226shiqian// Logging: 126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_LOG_() - logs messages at the specified severity level. 127d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 128d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 129d201456903f3ecae1f7794edfab0d5678e64226shiqian// 130d201456903f3ecae1f7794edfab0d5678e64226shiqian// Stderr capturing: 131d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr() - starts capturing stderr. 132d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr() - stops capturing stderr and returns the captured 133d201456903f3ecae1f7794edfab0d5678e64226shiqian// string. 134d201456903f3ecae1f7794edfab0d5678e64226shiqian// 135d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types: 136d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize - maps an integer to a int type. 137d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32, UInt32, Int64, UInt64, TimeInMillis 138d201456903f3ecae1f7794edfab0d5678e64226shiqian// - integers of known sizes. 139d201456903f3ecae1f7794edfab0d5678e64226shiqian// BiggestInt - the biggest signed integer type. 140d201456903f3ecae1f7794edfab0d5678e64226shiqian// 141d201456903f3ecae1f7794edfab0d5678e64226shiqian// Command-line utilities: 142d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_FLAG() - references a flag. 143d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DECLARE_*() - declares a flag. 144d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_DEFINE_*() - defines a flag. 145d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetArgvs() - returns the command line as a vector of strings. 146d201456903f3ecae1f7794edfab0d5678e64226shiqian// 147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variable utilities: 148d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetEnv() - gets the value of an environment variable. 149d201456903f3ecae1f7794edfab0d5678e64226shiqian// BoolFromGTestEnv() - parses a bool environment variable. 150d201456903f3ecae1f7794edfab0d5678e64226shiqian// Int32FromGTestEnv() - parses an Int32 environment variable. 151d201456903f3ecae1f7794edfab0d5678e64226shiqian// StringFromGTestEnv() - parses a string environment variable. 152d201456903f3ecae1f7794edfab0d5678e64226shiqian 153d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 154d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdio.h> 1553c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <string.h> 1563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/stat.h> 1573c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 1583c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <iostream> // NOLINT 159d201456903f3ecae1f7794edfab0d5678e64226shiqian 16087d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 1610af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_ "gtest_" 1620af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 16387d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_NAME_ "Google Test" 16487d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 165d201456903f3ecae1f7794edfab0d5678e64226shiqian 16664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines the version of gcc that is used to compile this. 16764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GNUC__ 16864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// 40302 means version 4.3.2. 16964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_GCC_VER_ \ 17064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 17164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ 17264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 173d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines the platform on which Google Test is compiled. 174e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian#ifdef __CYGWIN__ 1750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_CYGWIN 1 176e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#elif __SYMBIAN32__ 1770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SYMBIAN 1 1786a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#elif defined _WIN32 1790af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_WINDOWS 1 180d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __APPLE__ 1810af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_MAC 1 182d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined __linux__ 1830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_LINUX 1 184d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined __MVS__ 1850af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_ZOS 1 186d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#elif defined(__sun) && defined(__SVR4) 1870af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_OS_SOLARIS 1 1886a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#endif // __CYGWIN__ 189d201456903f3ecae1f7794edfab0d5678e64226shiqian 1904984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC 191c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 192c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// On some platforms, <regex.h> needs someone to define size_t, and 193c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// won't compile otherwise. We can #include it here as we already 194c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// included <stdlib.h>, which is guaranteed to define size_t through 195c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan// <stddef.h>. 196c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#include <regex.h> // NOLINT 1973c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <strings.h> // NOLINT 1983c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <sys/types.h> // NOLINT 1993c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <unistd.h> // NOLINT 2003c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 201c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_POSIX_RE 1 202c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2033c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#elif GTEST_OS_WINDOWS 2043c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 2053c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <direct.h> // NOLINT 2063c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <io.h> // NOLINT 2073c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 2083c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// <regex.h> is not available on Windows. Use our own simple regex 2093c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// implementation instead. 2103c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 2113c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 212c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else 213c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 2144984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// <regex.h> may not be available on this platform. Use our own 2154984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// simple regex implementation instead. 216c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_USES_SIMPLE_RE 1 217c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 21844a041b711ff4a5b5f341f21127aed46dbfe38adzhanyong.wan#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC 219c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan 220886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0 221886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// otherwise. 222d201456903f3ecae1f7794edfab0d5678e64226shiqian 223c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 224c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 225c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// macro to enable exceptions, so we'll do the same. 226d201456903f3ecae1f7794edfab0d5678e64226shiqian// Assumes that exceptions are enabled by default. 227c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef _HAS_EXCEPTIONS 228d201456903f3ecae1f7794edfab0d5678e64226shiqian#define _HAS_EXCEPTIONS 1 229d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // _HAS_EXCEPTIONS 230d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 231c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#else // The compiler is not MSVC or C++Builder. 232886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For 233886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// other compilers, we assume exceptions are disabled to be 234886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// conservative. 2353c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#if defined(__GNUC__) && __EXCEPTIONS 2363c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 1 2373c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#else 2383c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_EXCEPTIONS 0 2393c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#endif // defined(__GNUC__) && __EXCEPTIONS 240c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // defined(_MSC_VER) || defined(__BORLANDC__) 241d201456903f3ecae1f7794edfab0d5678e64226shiqian 242886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// Determines whether ::std::string and ::string are available. 243886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan 244886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan#ifndef GTEST_HAS_STD_STRING 245886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// The user didn't tell us whether ::std::string is available, so we 246886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// need to figure it out. The only environment that we know 247886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// ::std::string is not available is MSVC 7.1 or lower with exceptions 248886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan// disabled. 2493c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS 2503c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_STD_STRING 0 2513c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#else 2523c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#define GTEST_HAS_STD_STRING 1 2533c7868a9a8fab4fd9209bbd2d2f1ae269d063680zhanyong.wan#endif 254d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 255d201456903f3ecae1f7794edfab0d5678e64226shiqian 256d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_STRING 257d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::string is available, so we need 258d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 259d201456903f3ecae1f7794edfab0d5678e64226shiqian 260d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_GLOBAL_STRING 0 261d201456903f3ecae1f7794edfab0d5678e64226shiqian 262d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 263d201456903f3ecae1f7794edfab0d5678e64226shiqian 264d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_STD_WSTRING 265d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::std::wstring is available, so we need 266d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 267d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 268d201456903f3ecae1f7794edfab0d5678e64226shiqian// is available. 269d201456903f3ecae1f7794edfab0d5678e64226shiqian 2700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS 271bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.5 and below doesn't support ::std::wstring. 272bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan// Cygwin 1.7 might add wstring support; this should be updated when clear. 273d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Solaris' libc++ doesn't support it either. 274d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_WSTRING 0 275d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 276d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING 2770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS 278d201456903f3ecae1f7794edfab0d5678e64226shiqian 279d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 280d201456903f3ecae1f7794edfab0d5678e64226shiqian 281d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef GTEST_HAS_GLOBAL_WSTRING 282d201456903f3ecae1f7794edfab0d5678e64226shiqian// The user didn't tell us whether ::wstring is available, so we need 283d201456903f3ecae1f7794edfab0d5678e64226shiqian// to figure it out. 284bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan#define GTEST_HAS_GLOBAL_WSTRING \ 285bbab12725025270beb12cb62a73b9cfc33bdec85zhanyong.wan (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 286d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 287d201456903f3ecae1f7794edfab0d5678e64226shiqian 288d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \ 289d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 290d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <string> // NOLINT 291d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || 292d201456903f3ecae1f7794edfab0d5678e64226shiqian // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 293d201456903f3ecae1f7794edfab0d5678e64226shiqian 294d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 295d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <sstream> // NOLINT 296d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 297d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <strstream> // NOLINT 298d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 299d201456903f3ecae1f7794edfab0d5678e64226shiqian 30064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Determines whether RTTI is available. 30164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifndef GTEST_HAS_RTTI 30264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// The user didn't tell us whether RTTI is enabled, so we need to 30364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// figure it out. 30464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 30564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _MSC_VER 30664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 30764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 30864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 30964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 31064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 31164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // _CPPRTTI 31264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 31364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#elif defined(__GNUC__) 31464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 31564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 31664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if GTEST_GCC_VER_ >= 40302 31764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#ifdef __GXX_RTTI 31864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 31964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 32064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 0 32164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GXX_RTTI 32264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 32364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// For gcc versions smaller than 4.3.2, we assume RTTI is enabled. 32464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 32564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // GTEST_GCC_VER >= 40302 32664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 32764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#else 32864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 32964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Unknown compiler - assume RTTI is enabled. 33064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#define GTEST_HAS_RTTI 1 33164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // _MSC_VER 33364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 33464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // GTEST_HAS_RTTI 33564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 336e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Determines whether <pthread.h> is available. 337e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#ifndef GTEST_HAS_PTHREAD 338e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The user didn't tell us, so we need to figure it out. 3390af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) 340e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_HAS_PTHREAD 341e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3425145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// Determines whether tr1/tuple is available. If you have tr1/tuple 3433d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// on your platform, define GTEST_HAS_TR1_TUPLE=1 for both the Google 3443d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Test project and your tests. If you would like Google Test to detect 3455145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple on your platform automatically, please open an issue 3463d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// ticket at http://code.google.com/p/googletest. 3473d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#ifndef GTEST_HAS_TR1_TUPLE 3483d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// The user didn't tell us, so we need to figure it out. 3493d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 3503d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GCC provides <tr1/tuple> since 4.0.0. 3513d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 3523d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_TR1_TUPLE 1 3533d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else 3543d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_HAS_TR1_TUPLE 0 3553d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif // __GNUC__ 3563d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif // GTEST_HAS_TR1_TUPLE 3573d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 3585145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// To avoid conditional compilation everywhere, we make it 3595145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// gtest-port.h's responsibility to #include the header implementing 3605145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// tr1/tuple. 3615145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if GTEST_HAS_TR1_TUPLE 3625145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#if defined(__GNUC__) 3635145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// GCC implements tr1/tuple in the <tr1/tuple> header. This does not 3645145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// conform to the TR1 spec, which requires the header to be <tuple>. 3655145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#include <tr1/tuple> 3665145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#else 3675145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// If the compiler is not GCC, we assume the user is using a 3685145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian// spec-conforming TR1 implementation. 3695145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#include <tuple> 3705145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif // __GNUC__ 3715145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian#endif // GTEST_HAS_TR1_TUPLE 3725145e0fb203071648f4be6b77c68fabf3d92ab8ashiqian 37304f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Determines whether clone(2) is supported. 37404f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Usually it will only be available on Linux, excluding 37504f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Linux on the Itanium architecture. 37604f025dd5746fca83c6c32f1729b3449721dd60eshiqian// Also see http://linux.die.net/man/2/clone. 37704f025dd5746fca83c6c32f1729b3449721dd60eshiqian#ifndef GTEST_HAS_CLONE 37804f025dd5746fca83c6c32f1729b3449721dd60eshiqian// The user didn't tell us, so we need to figure it out. 37904f025dd5746fca83c6c32f1729b3449721dd60eshiqian 3800af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX && !defined(__ia64__) 38104f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 1 38204f025dd5746fca83c6c32f1729b3449721dd60eshiqian#else 38304f025dd5746fca83c6c32f1729b3449721dd60eshiqian#define GTEST_HAS_CLONE 0 3840af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_LINUX && !defined(__ia64__) 38504f025dd5746fca83c6c32f1729b3449721dd60eshiqian 38604f025dd5746fca83c6c32f1729b3449721dd60eshiqian#endif // GTEST_HAS_CLONE 38704f025dd5746fca83c6c32f1729b3449721dd60eshiqian 388d201456903f3ecae1f7794edfab0d5678e64226shiqian// Determines whether to support death tests. 3894984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// Google Test does not support death tests for VC 7.1 and earlier for 3904984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// these reasons: 3914984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// 1. std::vector does not build in VC 7.1 when exceptions are disabled. 3924984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// 2. std::string does not build in VC 7.1 when exceptions are disabled 3934984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// (this is covered by GTEST_HAS_STD_STRING guard). 3944984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// 3. abort() in a VC 7.1 application compiled as GUI in debug config 3954984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// pops up a dialog window that cannot be suppressed programmatically. 3969623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan#if GTEST_HAS_STD_STRING && (GTEST_OS_LINUX || \ 3979623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan GTEST_OS_MAC || \ 3989623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan GTEST_OS_CYGWIN || \ 3999623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan (GTEST_OS_WINDOWS && _MSC_VER >= 1400)) 4000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_DEATH_TEST 1 4013c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#include <vector> // NOLINT 4029623aed82cf3e0dcd2fb2fb7442a5a9507ac55a5zhanyong.wan#endif 403d201456903f3ecae1f7794edfab0d5678e64226shiqian 4043d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support value-parameterized tests. 4053d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 4063d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if defined(__GNUC__) || (_MSC_VER >= 1400) 4073d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// TODO(vladl@google.com): get the implementation rid of vector and list 4083d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// to compile on MSVC 7.1. 4090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_PARAM_TEST 1 4103d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 4113d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 412a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Determines whether to support type-driven tests. 413a2b1a8556ea64014606d78b09333d9c522430a25shiqian 414a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Typed tests need <typeinfo> and variadic macros, which gcc and VC 415a2b1a8556ea64014606d78b09333d9c522430a25shiqian// 8.0+ support. 416a2b1a8556ea64014606d78b09333d9c522430a25shiqian#if defined(__GNUC__) || (_MSC_VER >= 1400) 417c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST 1 418c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#define GTEST_HAS_TYPED_TEST_P 1 419a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 420a2b1a8556ea64014606d78b09333d9c522430a25shiqian 4213d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Determines whether to support Combine(). This only makes sense when 4223d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// value-parameterized tests are enabled. 4230af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 4240af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_HAS_COMBINE 1 4250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 4263d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 4270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Determines whether the system compiler uses UTF-16 for encoding wide strings. 4280af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_WIDE_STRING_USES_UTF16_ \ 4290af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN) 4300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 431d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines some utility macros. 432d201456903f3ecae1f7794edfab0d5678e64226shiqian 433d201456903f3ecae1f7794edfab0d5678e64226shiqian// The GNU compiler emits a warning if nested "if" statements are followed by 434d201456903f3ecae1f7794edfab0d5678e64226shiqian// an "else" statement and braces are not used to explicitly disambiguate the 435d201456903f3ecae1f7794edfab0d5678e64226shiqian// "else" binding. This leads to problems with code like: 436d201456903f3ecae1f7794edfab0d5678e64226shiqian// 437d201456903f3ecae1f7794edfab0d5678e64226shiqian// if (gate) 438d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_*(condition) << "Some message"; 439d201456903f3ecae1f7794edfab0d5678e64226shiqian// 440d201456903f3ecae1f7794edfab0d5678e64226shiqian// The "switch (0) case 0:" idiom is used to suppress this. 441d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __INTEL_COMPILER 442e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 443d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 444e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 445d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 446d201456903f3ecae1f7794edfab0d5678e64226shiqian 4470da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Use this annotation at the end of a struct/class definition to 448d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent the compiler from optimizing away instances that are never 449d201456903f3ecae1f7794edfab0d5678e64226shiqian// used. This is useful when all interesting logic happens inside the 450d201456903f3ecae1f7794edfab0d5678e64226shiqian// c'tor and / or d'tor. Example: 451d201456903f3ecae1f7794edfab0d5678e64226shiqian// 452d201456903f3ecae1f7794edfab0d5678e64226shiqian// struct Foo { 453d201456903f3ecae1f7794edfab0d5678e64226shiqian// Foo() { ... } 454e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// } GTEST_ATTRIBUTE_UNUSED_; 4550da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// 4560da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// Also use it after a variable or parameter declaration to tell the 4570da92aaf7f696ebfa2374247ae9010dacbc057fczhanyong.wan// compiler the variable/parameter does not have to be used. 458bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#if defined(__GNUC__) && !defined(COMPILER_ICC) 459e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 460bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#else 461e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_ATTRIBUTE_UNUSED_ 462bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqian#endif 463d201456903f3ecae1f7794edfab0d5678e64226shiqian 464d201456903f3ecae1f7794edfab0d5678e64226shiqian// A macro to disallow the evil copy constructor and operator= functions 465d201456903f3ecae1f7794edfab0d5678e64226shiqian// This should be used in the private: declarations for a class. 466e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 467d201456903f3ecae1f7794edfab0d5678e64226shiqian type(const type &);\ 468d201456903f3ecae1f7794edfab0d5678e64226shiqian void operator=(const type &) 469d201456903f3ecae1f7794edfab0d5678e64226shiqian 470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tell the compiler to warn about unused return values for functions declared 471d201456903f3ecae1f7794edfab0d5678e64226shiqian// with this macro. The macro should be used on function declarations 472d201456903f3ecae1f7794edfab0d5678e64226shiqian// following the argument list: 473d201456903f3ecae1f7794edfab0d5678e64226shiqian// 474e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 47564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 476e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 477d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 478e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_MUST_USE_RESULT_ 47964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 480d201456903f3ecae1f7794edfab0d5678e64226shiqian 481f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Determine whether the compiler supports Microsoft's Structured Exception 482f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Handling. This is supported by several Windows compilers but generally 483f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// does not exist on any other system. 484f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#ifndef GTEST_HAS_SEH 485f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// The user didn't tell us, so we need to figure it out. 486f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 487f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#if defined(_MSC_VER) || defined(__BORLANDC__) 488f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// These two compilers are known to support SEH. 489f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 1 490f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#else 491f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan// Assume no SEH. 492f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#define GTEST_HAS_SEH 0 493f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif 494f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 495f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan#endif // GTEST_HAS_SEH 496f2334aa19555063791ec16fe2b476ec00195bbb8zhanyong.wan 497d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 498d201456903f3ecae1f7794edfab0d5678e64226shiqian 499d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message; 500d201456903f3ecae1f7794edfab0d5678e64226shiqian 501d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 502d201456903f3ecae1f7794edfab0d5678e64226shiqian 503d201456903f3ecae1f7794edfab0d5678e64226shiqianclass String; 504d201456903f3ecae1f7794edfab0d5678e64226shiqian 505d201456903f3ecae1f7794edfab0d5678e64226shiqian// std::strstream is deprecated. However, we have to use it on 506d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows as std::stringstream won't compile on Windows when 507d201456903f3ecae1f7794edfab0d5678e64226shiqian// exceptions are disabled. We use std::stringstream on other 508d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms to avoid compiler warnings there. 509d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 510d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::stringstream StrStream; 511d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 512d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef ::std::strstream StrStream; 513d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 514d201456903f3ecae1f7794edfab0d5678e64226shiqian 515d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines scoped_ptr. 516d201456903f3ecae1f7794edfab0d5678e64226shiqian 517d201456903f3ecae1f7794edfab0d5678e64226shiqian// This implementation of scoped_ptr is PARTIAL - it only contains 518d201456903f3ecae1f7794edfab0d5678e64226shiqian// enough stuff to satisfy Google Test's need. 519d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 520d201456903f3ecae1f7794edfab0d5678e64226shiqianclass scoped_ptr { 521d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 522d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 523d201456903f3ecae1f7794edfab0d5678e64226shiqian ~scoped_ptr() { reset(); } 524d201456903f3ecae1f7794edfab0d5678e64226shiqian 525d201456903f3ecae1f7794edfab0d5678e64226shiqian T& operator*() const { return *ptr_; } 526d201456903f3ecae1f7794edfab0d5678e64226shiqian T* operator->() const { return ptr_; } 527d201456903f3ecae1f7794edfab0d5678e64226shiqian T* get() const { return ptr_; } 528d201456903f3ecae1f7794edfab0d5678e64226shiqian 529d201456903f3ecae1f7794edfab0d5678e64226shiqian T* release() { 530d201456903f3ecae1f7794edfab0d5678e64226shiqian T* const ptr = ptr_; 531d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = NULL; 532d201456903f3ecae1f7794edfab0d5678e64226shiqian return ptr; 533d201456903f3ecae1f7794edfab0d5678e64226shiqian } 534d201456903f3ecae1f7794edfab0d5678e64226shiqian 535d201456903f3ecae1f7794edfab0d5678e64226shiqian void reset(T* p = NULL) { 536d201456903f3ecae1f7794edfab0d5678e64226shiqian if (p != ptr_) { 537d201456903f3ecae1f7794edfab0d5678e64226shiqian if (sizeof(T) > 0) { // Makes sure T is a complete type. 538d201456903f3ecae1f7794edfab0d5678e64226shiqian delete ptr_; 539d201456903f3ecae1f7794edfab0d5678e64226shiqian } 540d201456903f3ecae1f7794edfab0d5678e64226shiqian ptr_ = p; 541d201456903f3ecae1f7794edfab0d5678e64226shiqian } 542d201456903f3ecae1f7794edfab0d5678e64226shiqian } 543d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 544d201456903f3ecae1f7794edfab0d5678e64226shiqian T* ptr_; 545d201456903f3ecae1f7794edfab0d5678e64226shiqian 546e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 547d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 548d201456903f3ecae1f7794edfab0d5678e64226shiqian 5493d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Defines RE. 550d201456903f3ecae1f7794edfab0d5678e64226shiqian 551d201456903f3ecae1f7794edfab0d5678e64226shiqian// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended 552d201456903f3ecae1f7794edfab0d5678e64226shiqian// Regular Expression syntax. 553d201456903f3ecae1f7794edfab0d5678e64226shiqianclass RE { 554d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 555d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs an RE from a string. 556d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 557d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 558d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 559d201456903f3ecae1f7794edfab0d5678e64226shiqian 560d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 561d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 562d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 563d201456903f3ecae1f7794edfab0d5678e64226shiqian 564d201456903f3ecae1f7794edfab0d5678e64226shiqian RE(const char* regex) { Init(regex); } // NOLINT 565d201456903f3ecae1f7794edfab0d5678e64226shiqian ~RE(); 566d201456903f3ecae1f7794edfab0d5678e64226shiqian 567d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the string representation of the regex. 568d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern() const { return pattern_; } 569d201456903f3ecae1f7794edfab0d5678e64226shiqian 5703d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // FullMatch(str, re) returns true iff regular expression re matches 5713d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // the entire str. 5723d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // PartialMatch(str, re) returns true iff regular expression re 5733d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // matches a substring of str (including str itself). 5743d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // 5753d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // TODO(wan@google.com): make FullMatch() and PartialMatch() work 5763d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // when str contains NUL characters. 577d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 5783d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::std::string& str, const RE& re) { 5793d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 5803d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 581d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::std::string& str, const RE& re) { 582d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 583d201456903f3ecae1f7794edfab0d5678e64226shiqian } 584d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 585d201456903f3ecae1f7794edfab0d5678e64226shiqian 586d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 5873d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const ::string& str, const RE& re) { 5883d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev return FullMatch(str.c_str(), re); 5893d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 590d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const ::string& str, const RE& re) { 591d201456903f3ecae1f7794edfab0d5678e64226shiqian return PartialMatch(str.c_str(), re); 592d201456903f3ecae1f7794edfab0d5678e64226shiqian } 593d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 594d201456903f3ecae1f7794edfab0d5678e64226shiqian 5953d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev static bool FullMatch(const char* str, const RE& re); 596d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool PartialMatch(const char* str, const RE& re); 597d201456903f3ecae1f7794edfab0d5678e64226shiqian 598d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 599d201456903f3ecae1f7794edfab0d5678e64226shiqian void Init(const char* regex); 600d201456903f3ecae1f7794edfab0d5678e64226shiqian 601d201456903f3ecae1f7794edfab0d5678e64226shiqian // We use a const char* instead of a string, as Google Test may be used 602d201456903f3ecae1f7794edfab0d5678e64226shiqian // where string is not available. We also do not use Google Test's own 603d201456903f3ecae1f7794edfab0d5678e64226shiqian // String type here, in order to simplify dependencies between the 604d201456903f3ecae1f7794edfab0d5678e64226shiqian // files. 605d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* pattern_; 606c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan bool is_valid_; 607c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#if GTEST_USES_POSIX_RE 6083d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t full_regex_; // For FullMatch(). 6093d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev regex_t partial_regex_; // For PartialMatch(). 610c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#else // GTEST_USES_SIMPLE_RE 611c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan const char* full_pattern_; // For FullMatch(); 612c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan#endif 613d201456903f3ecae1f7794edfab0d5678e64226shiqian 614c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(RE); 615c946ae60194727ede9d3ef44754839f48541a981zhanyong.wan}; 616d201456903f3ecae1f7794edfab0d5678e64226shiqian 617d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines logging utilities: 618e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// GTEST_LOG_() - logs messages at the specified severity level. 619d201456903f3ecae1f7794edfab0d5678e64226shiqian// LogToStderr() - directs all log messages to stderr. 620d201456903f3ecae1f7794edfab0d5678e64226shiqian// FlushInfoLog() - flushes informational log messages. 621d201456903f3ecae1f7794edfab0d5678e64226shiqian 622d201456903f3ecae1f7794edfab0d5678e64226shiqianenum GTestLogSeverity { 623d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_INFO, 624d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_WARNING, 625d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_ERROR, 626d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FATAL 627d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 628d201456903f3ecae1f7794edfab0d5678e64226shiqian 629d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid GTestLog(GTestLogSeverity severity, const char* file, 630d201456903f3ecae1f7794edfab0d5678e64226shiqian int line, const char* msg); 631d201456903f3ecae1f7794edfab0d5678e64226shiqian 632e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_LOG_(severity, msg)\ 633d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::GTestLog(\ 634d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::GTEST_##severity, __FILE__, __LINE__, \ 635d201456903f3ecae1f7794edfab0d5678e64226shiqian (::testing::Message() << (msg)).GetString().c_str()) 636d201456903f3ecae1f7794edfab0d5678e64226shiqian 637d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void LogToStderr() {} 638d201456903f3ecae1f7794edfab0d5678e64226shiqianinline void FlushInfoLog() { fflush(NULL); } 639d201456903f3ecae1f7794edfab0d5678e64226shiqian 640d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines the stderr capturer: 641d201456903f3ecae1f7794edfab0d5678e64226shiqian// CaptureStderr - starts capturing stderr. 642d201456903f3ecae1f7794edfab0d5678e64226shiqian// GetCapturedStderr - stops capturing stderr and returns the captured string. 643d201456903f3ecae1f7794edfab0d5678e64226shiqian 6444984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan#if GTEST_HAS_STD_STRING 6454984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanvoid CaptureStderr(); 6464984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan::std::string GetCapturedStderr(); 6474984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan#endif // GTEST_HAS_STD_STRING 6484984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 6490af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 650d201456903f3ecae1f7794edfab0d5678e64226shiqian 651d201456903f3ecae1f7794edfab0d5678e64226shiqian// A copy of all command line arguments. Set by InitGoogleTest(). 652d201456903f3ecae1f7794edfab0d5678e64226shiqianextern ::std::vector<String> g_argvs; 653d201456903f3ecae1f7794edfab0d5678e64226shiqian 654d201456903f3ecae1f7794edfab0d5678e64226shiqian// GTEST_HAS_DEATH_TEST implies we have ::std::string. 655d201456903f3ecae1f7794edfab0d5678e64226shiqianconst ::std::vector<String>& GetArgvs(); 656d201456903f3ecae1f7794edfab0d5678e64226shiqian 657d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_DEATH_TEST 658d201456903f3ecae1f7794edfab0d5678e64226shiqian 659d201456903f3ecae1f7794edfab0d5678e64226shiqian// Defines synchronization primitives. 660d201456903f3ecae1f7794edfab0d5678e64226shiqian 661d201456903f3ecae1f7794edfab0d5678e64226shiqian// A dummy implementation of synchronization primitives (mutex, lock, 662d201456903f3ecae1f7794edfab0d5678e64226shiqian// and thread-local variable). Necessary for compiling Google Test where 663d201456903f3ecae1f7794edfab0d5678e64226shiqian// mutex is not supported - using Google Test in multiple threads is not 664d201456903f3ecae1f7794edfab0d5678e64226shiqian// supported on such platforms. 665d201456903f3ecae1f7794edfab0d5678e64226shiqian 666d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Mutex { 667d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 668d201456903f3ecae1f7794edfab0d5678e64226shiqian Mutex() {} 669b75872639683cf572253f20863982324b113205eshiqian explicit Mutex(int /*unused*/) {} 670d201456903f3ecae1f7794edfab0d5678e64226shiqian void AssertHeld() const {} 671d201456903f3ecae1f7794edfab0d5678e64226shiqian enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 }; 672d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 673d201456903f3ecae1f7794edfab0d5678e64226shiqian 674d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot call it MutexLock directly as the ctor declaration would 675d201456903f3ecae1f7794edfab0d5678e64226shiqian// conflict with a macro named MutexLock, which is defined on some 676d201456903f3ecae1f7794edfab0d5678e64226shiqian// platforms. Hence the typedef trick below. 677d201456903f3ecae1f7794edfab0d5678e64226shiqianclass GTestMutexLock { 678d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 679d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit GTestMutexLock(Mutex*) {} // NOLINT 680d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 681d201456903f3ecae1f7794edfab0d5678e64226shiqian 682d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef GTestMutexLock MutexLock; 683d201456903f3ecae1f7794edfab0d5678e64226shiqian 684d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 685d201456903f3ecae1f7794edfab0d5678e64226shiqianclass ThreadLocal { 686d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 687e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal() : value_() {} 688e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian explicit ThreadLocal(const T& value) : value_(value) {} 689d201456903f3ecae1f7794edfab0d5678e64226shiqian T* pointer() { return &value_; } 690d201456903f3ecae1f7794edfab0d5678e64226shiqian const T* pointer() const { return &value_; } 691d201456903f3ecae1f7794edfab0d5678e64226shiqian const T& get() const { return value_; } 692d201456903f3ecae1f7794edfab0d5678e64226shiqian void set(const T& value) { value_ = value; } 693d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 694d201456903f3ecae1f7794edfab0d5678e64226shiqian T value_; 695d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 696d201456903f3ecae1f7794edfab0d5678e64226shiqian 697c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// Returns the number of threads running in the process, or 0 to indicate that 698c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// we cannot detect it. 699c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wansize_t GetThreadCount(); 700d201456903f3ecae1f7794edfab0d5678e64226shiqian 701e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// The above synchronization primitives have dummy implementations. 702e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Therefore Google Test is not thread-safe. 703e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_IS_THREADSAFE 0 704e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 705d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 706d2849f573052ba8431a887e0034b1be353a0d9b4shiqian 707d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// Passing non-POD classes through ellipsis (...) crashes the ARM 708d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to 709d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// instantiate a copy constructor for objects passed through ellipsis 710d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// (...), failing for uncopyable objects. We define this to indicate 711d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// the fact. 712d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_ELLIPSIS_NEEDS_COPY_ 1 713d201456903f3ecae1f7794edfab0d5678e64226shiqian 714d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 715d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// const T& and const T* in a function template. These compilers 716d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// _can_ decide between class template specializations for T and T*, 717d2849f573052ba8431a887e0034b1be353a0d9b4shiqian// so a tr1::type_traits-like is_pointer works. 718d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#define GTEST_NEEDS_IS_POINTER_ 1 719d201456903f3ecae1f7794edfab0d5678e64226shiqian 720d2849f573052ba8431a887e0034b1be353a0d9b4shiqian#endif // defined(__SYMBIAN32__) || defined(__IBMCPP__) 721d201456903f3ecae1f7794edfab0d5678e64226shiqian 722d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> 723d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct bool_constant { 724d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef bool_constant<bool_value> type; 725d201456903f3ecae1f7794edfab0d5678e64226shiqian static const bool value = bool_value; 726d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 727d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <bool bool_value> const bool bool_constant<bool_value>::value; 728d201456903f3ecae1f7794edfab0d5678e64226shiqian 729d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<false> false_type; 730d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef bool_constant<true> true_type; 731d201456903f3ecae1f7794edfab0d5678e64226shiqian 732d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 733d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer : public false_type {}; 734d201456903f3ecae1f7794edfab0d5678e64226shiqian 735d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 736d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct is_pointer<T*> : public true_type {}; 737d201456903f3ecae1f7794edfab0d5678e64226shiqian 73887d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#if GTEST_OS_WINDOWS 73987d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "\\" 7403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The biggest signed integer type the compiler supports. 7413c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef __int64 BiggestInt; 74287d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#else 74387d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#define GTEST_PATH_SEP_ "/" 7443c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wantypedef long long BiggestInt; // NOLINT 74587d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan#endif // GTEST_OS_WINDOWS 74687d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan 7473c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// The testing::internal::posix namespace holds wrappers for common 7483c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// POSIX functions. These wrappers hide the differences between 749f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// Windows/MSVC and POSIX systems. Since some compilers define these 750f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// standard functions as macros, the wrapper cannot have the same name 751f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan// as the wrapped function. 752f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan 7533c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wannamespace posix { 7543c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 7553c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions with a different name on Windows. 7563c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 7570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 7583c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 759f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct _stat StatStruct; 7603c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 761c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 762c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 763c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 764c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return stricmp(s1, s2); 765c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 766c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 767c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#else 768f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return _isatty(fd); } 769f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 770f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return _stricmp(s1, s2); 7713c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 772f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline char* StrDup(const char* src) { return _strdup(src); } 773c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // __BORLANDC__ 774c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 775c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int FileNo(FILE* file) { return _fileno(file); } 776c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 777f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return _rmdir(dir); } 778f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { 7793c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return (_S_IFDIR & st.st_mode) != 0; 7803c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 7813c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 782d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 7833c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 784f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wantypedef struct stat StatStruct; 7853c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 786f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FileNo(FILE* file) { return fileno(file); } 787f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int IsATTY(int fd) { return isatty(fd); } 788f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 789f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int StrCaseCmp(const char* s1, const char* s2) { 790f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strcasecmp(s1, s2); 791f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan} 792c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.waninline char* StrDup(const char* src) { return strdup(src); } 793f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int RmDir(const char* dir) { return rmdir(dir); } 794f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 7953c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 796d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 797d201456903f3ecae1f7794edfab0d5678e64226shiqian 7983c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Functions deprecated by MSVC 8.0. 7993c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8003c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 8013c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Temporarily disable warning 4996 (deprecated function). 8023c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(push) 8033c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(disable:4996) 8043c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 8053c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 806f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrNCpy(char* dest, const char* src, size_t n) { 807f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return strncpy(dest, src, n); 8083c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 809f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int ChDir(const char* dir) { return chdir(dir); } 810f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FOpen(const char* path, const char* mode) { 811f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return fopen(path, mode); 8123c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 813f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 814f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return freopen(path, mode, stream); 8153c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 816f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 817f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int FClose(FILE* fp) { return fclose(fp); } 818f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Read(int fd, void* buf, unsigned int count) { 819f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(read(fd, buf, count)); 8203c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 821f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Write(int fd, const void* buf, unsigned int count) { 822f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return static_cast<int>(write(fd, buf, count)); 8233c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 824f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline int Close(int fd) { return close(fd); } 825f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* StrError(int errnum) { return strerror(errnum); } 826f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline const char* GetEnv(const char* name) { 8273c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _WIN32_WCE // We are on Windows CE, which has no environment variables. 8283c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan return NULL; 829c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#elif defined(__BORLANDC__) 830c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Environment variables which we programmatically clear will be set to the 831c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // empty string rather than unset (NULL). Handle that case. 832c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const char* const env = getenv(name); 833c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan return (env != NULL && env[0] != '\0') ? env : NULL; 8343c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 835f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan return getenv(name); 8363c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 8373c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} 8383c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8393c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _MSC_VER 8403c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#pragma warning(pop) // Restores the warning state. 8413c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif 8423c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8433c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#ifdef _WIN32_WCE 8443c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// Windows CE has no C library. The abort() function is used in 8453c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// several places in Google Test. This implementation provides a reasonable 8463c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan// imitation of standard behaviour. 847f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wanvoid Abort(); 8483c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#else 849f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.waninline void Abort() { abort(); } 8503c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan#endif // _WIN32_WCE 8513c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 8523c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan} // namespace posix 8533c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wan 854d201456903f3ecae1f7794edfab0d5678e64226shiqian// The maximum number a BiggestInt can represent. This definition 855d201456903f3ecae1f7794edfab0d5678e64226shiqian// works no matter BiggestInt is represented in one's complement or 856d201456903f3ecae1f7794edfab0d5678e64226shiqian// two's complement. 857d201456903f3ecae1f7794edfab0d5678e64226shiqian// 858d201456903f3ecae1f7794edfab0d5678e64226shiqian// We cannot rely on numeric_limits in STL, as __int64 and long long 859d201456903f3ecae1f7794edfab0d5678e64226shiqian// are not part of standard C++ and numeric_limits doesn't need to be 860d201456903f3ecae1f7794edfab0d5678e64226shiqian// defined for them. 861d201456903f3ecae1f7794edfab0d5678e64226shiqianconst BiggestInt kMaxBiggestInt = 862d201456903f3ecae1f7794edfab0d5678e64226shiqian ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 863d201456903f3ecae1f7794edfab0d5678e64226shiqian 864d201456903f3ecae1f7794edfab0d5678e64226shiqian// This template class serves as a compile-time function from size to 865d201456903f3ecae1f7794edfab0d5678e64226shiqian// type. It maps a size in bytes to a primitive type with that 866d201456903f3ecae1f7794edfab0d5678e64226shiqian// size. e.g. 867d201456903f3ecae1f7794edfab0d5678e64226shiqian// 868d201456903f3ecae1f7794edfab0d5678e64226shiqian// TypeWithSize<4>::UInt 869d201456903f3ecae1f7794edfab0d5678e64226shiqian// 870d201456903f3ecae1f7794edfab0d5678e64226shiqian// is typedef-ed to be unsigned int (unsigned integer made up of 4 871d201456903f3ecae1f7794edfab0d5678e64226shiqian// bytes). 872d201456903f3ecae1f7794edfab0d5678e64226shiqian// 873d201456903f3ecae1f7794edfab0d5678e64226shiqian// Such functionality should belong to STL, but I cannot find it 874d201456903f3ecae1f7794edfab0d5678e64226shiqian// there. 875d201456903f3ecae1f7794edfab0d5678e64226shiqian// 876d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test uses this class in the implementation of floating-point 877d201456903f3ecae1f7794edfab0d5678e64226shiqian// comparison. 878d201456903f3ecae1f7794edfab0d5678e64226shiqian// 879d201456903f3ecae1f7794edfab0d5678e64226shiqian// For now it only handles UInt (unsigned int) as that's all Google Test 880d201456903f3ecae1f7794edfab0d5678e64226shiqian// needs. Other types can be easily added in the future if need 881d201456903f3ecae1f7794edfab0d5678e64226shiqian// arises. 882d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <size_t size> 883d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize { 884d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 885d201456903f3ecae1f7794edfab0d5678e64226shiqian // This prevents the user from using TypeWithSize<N> with incorrect 886d201456903f3ecae1f7794edfab0d5678e64226shiqian // values of N. 887d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef void UInt; 888d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 889d201456903f3ecae1f7794edfab0d5678e64226shiqian 890d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 4. 891d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 892d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<4> { 893d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 894d201456903f3ecae1f7794edfab0d5678e64226shiqian // unsigned int has size 4 in both gcc and MSVC. 895d201456903f3ecae1f7794edfab0d5678e64226shiqian // 896d201456903f3ecae1f7794edfab0d5678e64226shiqian // As base/basictypes.h doesn't compile on Windows, we cannot use 897d201456903f3ecae1f7794edfab0d5678e64226shiqian // uint32, uint64, and etc here. 898d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef int Int; 899d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned int UInt; 900d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 901d201456903f3ecae1f7794edfab0d5678e64226shiqian 902d201456903f3ecae1f7794edfab0d5678e64226shiqian// The specialization for size 8. 903d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <> 904d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TypeWithSize<8> { 905d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 9060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 907d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef __int64 Int; 908d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned __int64 UInt; 909d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 910d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef long long Int; // NOLINT 911d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef unsigned long long UInt; // NOLINT 912d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 913d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 914d201456903f3ecae1f7794edfab0d5678e64226shiqian 915d201456903f3ecae1f7794edfab0d5678e64226shiqian// Integer types of known sizes. 916d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::Int Int32; 917d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<4>::UInt UInt32; 918d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int Int64; 919d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::UInt UInt64; 920d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 921d201456903f3ecae1f7794edfab0d5678e64226shiqian 922d201456903f3ecae1f7794edfab0d5678e64226shiqian// Utilities for command line flags and environment variables. 923d201456903f3ecae1f7794edfab0d5678e64226shiqian 9243d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// INTERNAL IMPLEMENTATION - DO NOT USE. 9253d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// 9263d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 9273d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// is not satisfied. 9283d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Synopsys: 9293d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_(boolean_condition); 9303d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// or 9313d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// GTEST_CHECK_(boolean_condition) << "Additional message"; 9323d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// 9333d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// This checks the condition and if the condition is not satisfied 9343d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// it prints message about the condition violation, including the 9353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// condition itself, plus additional message streamed into it, if any, 9363d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// and then it aborts the program. It aborts the program irrespective of 9373d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// whether it is built in the debug mode or not. 9383d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevclass GTestCheckProvider { 9393d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev public: 9403d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev GTestCheckProvider(const char* condition, const char* file, int line) { 9413d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev FormatFileLocation(file, line); 9423d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::cerr << " ERROR: Condition " << condition << " failed. "; 9433d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 9443d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ~GTestCheckProvider() { 9453d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::cerr << ::std::endl; 9463d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev abort(); 9473d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 9483d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev void FormatFileLocation(const char* file, int line) { 9493d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev if (file == NULL) 9503d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev file = "unknown file"; 9513d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev if (line < 0) { 9523d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::cerr << file << ":"; 9533d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } else { 9543d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#if _MSC_VER 9553d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::cerr << file << "(" << line << "):"; 9563d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#else 9573d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::cerr << file << ":" << line << ":"; 9583d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#endif 9593d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 9603d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev } 9613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::std::ostream& GetStream() { return ::std::cerr; } 9623d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev}; 9633d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev#define GTEST_CHECK_(condition) \ 9643d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 9653d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev if (condition) \ 9663d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ; \ 9673d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev else \ 9683d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ::testing::internal::GTestCheckProvider(\ 9693d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev #condition, __FILE__, __LINE__).GetStream() 9703d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 971d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macro for referencing flags. 972d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_FLAG(name) FLAGS_gtest_##name 973d201456903f3ecae1f7794edfab0d5678e64226shiqian 974d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for declaring flags. 975e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name) 976e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_int32_(name) \ 977d201456903f3ecae1f7794edfab0d5678e64226shiqian extern ::testing::internal::Int32 GTEST_FLAG(name) 978e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DECLARE_string_(name) \ 979d201456903f3ecae1f7794edfab0d5678e64226shiqian extern ::testing::internal::String GTEST_FLAG(name) 980d201456903f3ecae1f7794edfab0d5678e64226shiqian 981d201456903f3ecae1f7794edfab0d5678e64226shiqian// Macros for defining flags. 982e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_bool_(name, default_val, doc) \ 983d201456903f3ecae1f7794edfab0d5678e64226shiqian bool GTEST_FLAG(name) = (default_val) 984e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_int32_(name, default_val, doc) \ 985d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 986e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_DEFINE_string_(name, default_val, doc) \ 987d201456903f3ecae1f7794edfab0d5678e64226shiqian ::testing::internal::String GTEST_FLAG(name) = (default_val) 988d201456903f3ecae1f7794edfab0d5678e64226shiqian 989d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses 'str' for a 32-bit signed integer. If successful, writes the result 990d201456903f3ecae1f7794edfab0d5678e64226shiqian// to *value and returns true; otherwise leaves *value unchanged and returns 991d201456903f3ecae1f7794edfab0d5678e64226shiqian// false. 992d201456903f3ecae1f7794edfab0d5678e64226shiqian// TODO(chandlerc): Find a better way to refactor flag and environment parsing 993d201456903f3ecae1f7794edfab0d5678e64226shiqian// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 994d201456903f3ecae1f7794edfab0d5678e64226shiqian// function. 995d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32(const Message& src_text, const char* str, Int32* value); 996d201456903f3ecae1f7794edfab0d5678e64226shiqian 997d201456903f3ecae1f7794edfab0d5678e64226shiqian// Parses a bool/Int32/string from the environment variable 998d201456903f3ecae1f7794edfab0d5678e64226shiqian// corresponding to the given Google Test flag. 999d201456903f3ecae1f7794edfab0d5678e64226shiqianbool BoolFromGTestEnv(const char* flag, bool default_val); 1000d201456903f3ecae1f7794edfab0d5678e64226shiqianInt32 Int32FromGTestEnv(const char* flag, Int32 default_val); 1001d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* StringFromGTestEnv(const char* flag, const char* default_val); 1002d201456903f3ecae1f7794edfab0d5678e64226shiqian 1003d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 1004d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 1005d201456903f3ecae1f7794edfab0d5678e64226shiqian 1006d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1007