111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Copyright 2005, Google Inc. 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// All rights reserved. 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Redistribution and use in source and binary forms, with or without 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// modification, are permitted provided that the following conditions are 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// met: 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions of source code must retain the above copyright 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// notice, this list of conditions and the following disclaimer. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions in binary form must reproduce the above 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// copyright notice, this list of conditions and the following disclaimer 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in the documentation and/or other materials provided with the 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// distribution. 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Neither the name of Google Inc. nor the names of its 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// contributors may be used to endorse or promote products derived from 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// this software without specific prior written permission. 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Authors: wan@google.com (Zhanyong Wan) 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Low-level types and utilities for porting Google Test to various 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platforms. They are subject to change without notice. DO NOT USE 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THEM IN USER CODE. 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This file is fundamental to Google Test. All other Google Test source 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// files are expected to #include this. Therefore, it cannot #include 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// any other Google Test header. 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user can define the following macros in the build script to 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// control Google Test's behavior. If the user doesn't define a macro 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in this list, Google Test will define it. 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is/isn't available. 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are enabled. 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is/isn't available (some systems define 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::string, which is different to std::string). 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is/isn't available (some systems define 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::wstring, which is different to std::wstring). 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// expressions are/aren't available. 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is/isn't available. 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// enabled. 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// std::wstring does/doesn't work (Google Test can 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be used where std::wstring is unavailable). 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is/isn't available. 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// compiler supports Microsoft's "Structured 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Exception Handling". 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_STREAM_REDIRECTION 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - Define it to 1/0 to indicate whether the 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platform supports I/O stream redirection using 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// dup() and dup2(). 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Test's own tr1 tuple implementation should be 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// used. Unused when the user sets 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_TR1_TUPLE to 0. 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is building in C++11/C++98 mode. 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_LINKED_AS_SHARED_LIBRARY 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - Define to 1 when compiling tests that use 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test as a shared library (known as 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DLL on Windows). 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_CREATE_SHARED_LIBRARY 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - Define to 1 when compiling Google Test itself 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as a shared library. 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This header defines the following utilities: 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macros indicating the current platform (defined to 1 if compiled on 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the given platform; otherwise undefined): 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_AIX - IBM AIX 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_CYGWIN - Cygwin 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_HPUX - HP-UX 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_LINUX - Linux 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_LINUX_ANDROID - Google Android 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_MAC - Mac OS X 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_IOS - iOS 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_IOS_SIMULATOR - iOS simulator 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_NACL - Google Native Client (NaCl) 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_OPENBSD - OpenBSD 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_QNX - QNX 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_SOLARIS - Sun Solaris 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_SYMBIAN - Symbian 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_WINDOWS_MINGW - MinGW 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_OS_ZOS - z/OS 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// most stable support. Since core members of the Google Test project 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// don't have access to other platforms, support for them may be less 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// stable. If you notice any problems on your platform, please notify 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// googletestframework@googlegroups.com (patches for fixing them are 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// even more welcome!). 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Note that it is possible that none of the GTEST_OS_* macros are defined. 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macros indicating available Google Test features (defined to 1 if 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the corresponding feature is supported; otherwise undefined): 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tests) 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_DEATH_TEST - death tests 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_PARAM_TEST - value-parameterized tests 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_TYPED_TEST - typed tests 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_HAS_POSIX_RE (see above) which users can 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// define themselves. 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_USES_SIMPLE_RE - our own simple regex is used; 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the above two are mutually exclusive. 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macros for basic C++ coding: 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// variable don't have to be used. 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DISALLOW_ASSIGN_ - disables operator=. 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Synchronization: 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Mutex, MutexLock, ThreadLocal, GetThreadCount() 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - synchronization primitives. 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// synchronization primitives have real implementations 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and Google Test is thread-safe; or 0 otherwise. 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Template meta programming: 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// IteratorTraits - partial implementation of std::iterator_traits, which 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is not available in libCstd when compiled with Sun C++. 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Smart pointers: 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// scoped_ptr - as in TR2. 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Regular expressions: 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// RE - a simple regular expression class using the POSIX 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Extended Regular Expression syntax on UNIX-like 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platforms, or a reduced regular exception syntax on 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// other platforms, including Windows. 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Logging: 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_LOG_() - logs messages at the specified severity level. 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LogToStderr() - directs all log messages to stderr. 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// FlushInfoLog() - flushes informational log messages. 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Stdout and stderr capturing: 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// CaptureStdout() - starts capturing stdout. 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetCapturedStdout() - stops capturing stdout and returns the captured 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// string. 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// CaptureStderr() - starts capturing stderr. 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetCapturedStderr() - stops capturing stderr and returns the captured 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// string. 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Integer types: 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TypeWithSize - maps an integer to a int type. 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Int32, UInt32, Int64, UInt64, TimeInMillis 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - integers of known sizes. 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// BiggestInt - the biggest signed integer type. 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Command-line utilities: 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_FLAG() - references a flag. 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DECLARE_*() - declares a flag. 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DEFINE_*() - defines a flag. 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetInjectableArgvs() - returns the command line as a vector of strings. 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Environment variable utilities: 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetEnv() - gets the value of an environment variable. 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// BoolFromGTestEnv() - parses a bool environment variable. 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Int32FromGTestEnv() - parses an Int32 environment variable. 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// StringFromGTestEnv() - parses a string environment variable. 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <ctype.h> // for isspace, etc 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stddef.h> // for ptrdiff_t 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stdlib.h> 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stdio.h> 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string.h> 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _WIN32_WCE 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <sys/types.h> 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <sys/stat.h> 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !_WIN32_WCE 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined __APPLE__ 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <AvailabilityMacros.h> 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <TargetConditionals.h> 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <iostream> // NOLINT 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <sstream> // NOLINT 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string> // NOLINT 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_FLAG_PREFIX_ "gtest_" 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_FLAG_PREFIX_DASH_ "gtest-" 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_NAME_ "Google Test" 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines the version of gcc that is used to compile this. 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __GNUC__ 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 40302 means version 4.3.2. 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_GCC_VER_ \ 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // __GNUC__ 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines the platform on which Google Test is compiled. 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __CYGWIN__ 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_CYGWIN 1 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __SYMBIAN32__ 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_SYMBIAN 1 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined _WIN32 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_WINDOWS 1 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef _WIN32_WCE 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_WINDOWS_MOBILE 1 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__MINGW__) || defined(__MINGW32__) 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_WINDOWS_MINGW 1 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_WINDOWS_DESKTOP 1 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _WIN32_WCE 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __APPLE__ 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_MAC 1 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if TARGET_OS_IPHONE 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_IOS 1 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if TARGET_IPHONE_SIMULATOR 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_IOS_SIMULATOR 1 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __linux__ 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_LINUX 1 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined __ANDROID__ 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_LINUX_ANDROID 1 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __MVS__ 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_ZOS 1 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(__sun) && defined(__SVR4) 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_SOLARIS 1 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(_AIX) 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_AIX 1 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(__hpux) 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_HPUX 1 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __native_client__ 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_NACL 1 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __OpenBSD__ 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_OPENBSD 1 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined __QNX__ 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_OS_QNX 1 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // __CYGWIN__ 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_LANG_CXX11 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// value for __cplusplus, and recent versions of clang, gcc, and 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// probably other compilers set that too in C++11 mode. 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Compiling in at least C++11 mode. 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_LANG_CXX11 1 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_LANG_CXX11 0 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Brings in definitions for functions used in the testing::internal::posix 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// namespace (read, write, close, chdir, isatty, stat). We do not currently 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use them on Windows Mobile. 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This assumes that non-Windows OSes provide unistd.h. For OSes where this 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is not the case, we need to include headers that provide the functions 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mentioned above. 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <unistd.h> 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <strings.h> 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif !GTEST_OS_WINDOWS_MOBILE 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <direct.h> 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <io.h> 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_LINUX_ANDROID 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Used to define __ANDROID_API__ matching the target NDK API level. 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <android/api-level.h> // NOLINT 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines this to true iff Google Test can use POSIX regular expressions. 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_POSIX_RE 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX_ANDROID 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On Android, <regex.h> is only available starting with Gingerbread. 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_POSIX_RE 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On some platforms, <regex.h> needs someone to define size_t, and 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// won't compile otherwise. We can #include it here as we already 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// included <stdlib.h>, which is guaranteed to define size_t through 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <stddef.h>. 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <regex.h> // NOLINT 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_USES_POSIX_RE 1 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif GTEST_OS_WINDOWS 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <regex.h> is not available on Windows. Use our own simple regex 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implementation instead. 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_USES_SIMPLE_RE 1 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <regex.h> may not be available on this platform. Use our own 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// simple regex implementation instead. 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_USES_SIMPLE_RE 1 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_POSIX_RE 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_EXCEPTIONS 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us whether exceptions are enabled, so we need 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to figure it out. 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined(_MSC_VER) || defined(__BORLANDC__) 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// macro to enable exceptions, so we'll do the same. 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Assumes that exceptions are enabled by default. 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef _HAS_EXCEPTIONS 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _HAS_EXCEPTIONS 1 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _HAS_EXCEPTIONS 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__GNUC__) && __EXCEPTIONS 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS 1 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__SUNPRO_CC) 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sun Pro CC supports exceptions. However, there is no compile-time way of 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// detecting whether they are enabled or not. Therefore, we assume that 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// they are enabled unless the user tells us otherwise. 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS 1 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__IBMCPP__) && __EXCEPTIONS 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS 1 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__HP_aCC) 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Exception handling is in effect by default in HP aCC compiler. It has to 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be turned of by +noeh compiler option if desired. 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS 1 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// For other compilers, we assume exceptions are disabled to be 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// conservative. 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_EXCEPTIONS 0 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // defined(_MSC_VER) || defined(__BORLANDC__) 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined(GTEST_HAS_STD_STRING) 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Even though we don't use this macro any longer, we keep it in case 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// some clients still depend on it. 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_STD_STRING 1 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif !GTEST_HAS_STD_STRING 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user told us that ::std::string isn't available. 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# error "Google Test cannot be used where ::std::string isn't available." 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !defined(GTEST_HAS_STD_STRING) 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_GLOBAL_STRING 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us whether ::string is available, so we need 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to figure it out. 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_GLOBAL_STRING 0 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_STRING 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_STD_WSTRING 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us whether ::std::wstring is available, so we need 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to figure it out. 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is available. 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Cygwin 1.7 and below doesn't support ::std::wstring. 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Solaris' libc++ doesn't support it either. Android has 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// no support for it at least as recent as Froyo (2.2). 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_STD_WSTRING \ 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STD_WSTRING 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_GLOBAL_WSTRING 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us whether ::wstring is available, so we need 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to figure it out. 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_GLOBAL_WSTRING \ 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_WSTRING 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether RTTI is available. 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_RTTI 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us whether RTTI is enabled, so we need to 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// figure it out. 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef _MSC_VER 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 1 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 0 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef __GXX_RTTI 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// When building against STLport with the Android NDK and with 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// -frtti -fno-exceptions, the build fails at link time with undefined 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// references to __cxa_bad_typeid. Note sure if STL or toolchain bug, 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// so disable RTTI when detected. 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert !defined(__EXCEPTIONS) 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 0 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 1 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 0 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // __GXX_RTTI 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// first version with C++ support. 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__clang__) 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI __has_feature(cxx_rtti) 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// both the typeid and dynamic_cast features are present. 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef __RTTI_ALL__ 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 1 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 0 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// For all other compilers, we assume RTTI is enabled. 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_RTTI 1 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _MSC_VER 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_RTTI 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// It's this header's responsibility to #include <typeinfo> when RTTI 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is enabled. 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_RTTI 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <typeinfo> 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether Google Test can use the pthreads library. 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_PTHREAD 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us explicitly, so we assume pthreads support is 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// available on Linux and Mac. 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to your compiler flags. 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \ 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || GTEST_OS_QNX) 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_PTHREAD 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_PTHREAD 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// true. 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <pthread.h> // NOLINT 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// For timespec and nanosleep, used below. 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <time.h> // NOLINT 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether Google Test can use tr1/tuple. You can define 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// this macro to 0 to prevent Google Test from using tuple (any 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// feature depending on tuple with be disabled in this mode). 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_TR1_TUPLE 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>. 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_TR1_TUPLE 0 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us not to do it, so we assume it's OK. 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_TR1_TUPLE 1 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_TR1_TUPLE 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether Google Test's own tr1 tuple implementation 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// should be used. 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_USE_OWN_TR1_TUPLE 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us, so we need to figure it out. 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We use our own TR1 tuple if we aren't sure the user has an 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implementation of it already. At this time, libstdc++ 4.0.0+ and 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MSVC 2010 are the only mainstream standard libraries that come 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pretends to be GCC by defining __GNUC__ and friends, but cannot 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tuple in a 323 MB Feature Pack download, which we cannot assume the 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// user has. QNX's QCC compiler is a modified GCC but it doesn't 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// support TR1 tuple. libc++ only provides std::tuple, in C++11 mode, 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and it can be used with some compilers that define __GNUC__. 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \ 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_ENV_HAS_TR1_TUPLE_ 1 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// can build with clang but need to use gcc4.2's libstdc++). 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325) 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_ENV_HAS_STD_TUPLE_ 1 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_ 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_USE_OWN_TR1_TUPLE 0 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_USE_OWN_TR1_TUPLE 1 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_USE_OWN_TR1_TUPLE 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// To avoid conditional compilation everywhere, we make it 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// gtest-port.h's responsibility to #include the header implementing 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tr1/tuple. 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_TR1_TUPLE 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_USE_OWN_TR1_TUPLE 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include "gtest/internal/gtest-tuple.h" 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif GTEST_ENV_HAS_STD_TUPLE_ 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <tuple> 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// C++11 puts its tuple into the ::std namespace rather than 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there. 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This causes undefined behavior, but supported compilers react in 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the way we intend. 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace std { 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace tr1 { 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing ::std::get; 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing ::std::make_tuple; 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing ::std::tuple; 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing ::std::tuple_element; 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing ::std::tuple_size; 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif GTEST_OS_SYMBIAN 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use STLport's tuple implementation, which unfortunately doesn't 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// work as the copy of STLport distributed with Symbian is incomplete. 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use its own tuple implementation. 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef BOOST_HAS_TR1_TUPLE 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef BOOST_HAS_TR1_TUPLE 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // BOOST_HAS_TR1_TUPLE 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This prevents <boost/tr1/detail/config.hpp>, which defines 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <tuple> 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// not conform to the TR1 spec, which requires the header to be <tuple>. 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// which is #included by <tr1/tuple>, to not compile when RTTI is 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// disabled. _TR1_FUNCTIONAL is the header guard for 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <tr1/functional>. Hence the following #define is a hack to prevent 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <tr1/functional> from being included. 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define _TR1_FUNCTIONAL 1 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <tr1/tuple> 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef _TR1_FUNCTIONAL // Allows the user to #include 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // <tr1/functional> if he chooses to. 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <tr1/tuple> // NOLINT 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// If the compiler is not GCC 4.0+, we assume the user is using a 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// spec-conforming TR1 implementation. 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <tuple> // NOLINT 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_USE_OWN_TR1_TUPLE 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_TR1_TUPLE 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether clone(2) is supported. 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Usually it will only be available on Linux, excluding 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Linux on the Itanium architecture. 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Also see http://linux.die.net/man/2/clone. 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_CLONE 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us, so we need to figure it out. 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX && !defined(__ia64__) 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX_ANDROID 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On Android, clone() is only available starting with Gingerbread. 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if __ANDROID_API__ >= 9 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CLONE 1 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CLONE 0 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CLONE 1 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CLONE 0 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX && !defined(__ia64__) 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_CLONE 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether to support stream redirection. This is used to test 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// output correctness and to implement death tests. 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_STREAM_REDIRECTION 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// By default, we assume that stream redirection is supported on all 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platforms except known mobile ones. 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_STREAM_REDIRECTION 0 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_STREAM_REDIRECTION 1 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STREAM_REDIRECTION 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether to support death tests. 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test does not support death tests for VC 7.1 and earlier as 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// abort() in a VC 7.1 application compiled as GUI in debug config 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pops up a dialog window that cannot be suppressed programmatically. 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \ 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \ 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_OS_OPENBSD || GTEST_OS_QNX) 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_DEATH_TEST 1 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <vector> // NOLINT 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We don't support MSVC 7.1 with exceptions disabled now. Therefore 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// all the compilers we care about are adequate for supporting 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// value-parameterized tests. 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_HAS_PARAM_TEST 1 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether to support type-driven tests. 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sun Pro CC, IBM Visual Age, and HP aCC support. 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert defined(__IBMCPP__) || defined(__HP_aCC) 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_TYPED_TEST 1 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_TYPED_TEST_P 1 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether to support Combine(). This only makes sense when 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// value-parameterized tests are enabled. The implementation doesn't 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// work on Sun Studio since it doesn't understand templated conversion 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// operators. 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_COMBINE 1 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether the system compiler uses UTF-16 for encoding wide strings. 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_WIDE_STRING_USES_UTF16_ \ 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determines whether test results can be streamed to a socket. 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_LINUX 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_CAN_STREAM_RESULTS_ 1 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines some utility macros. 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The GNU compiler emits a warning if nested "if" statements are followed by 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// an "else" statement and braces are not used to explicitly disambiguate the 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// "else" binding. This leads to problems with code like: 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if (gate) 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ASSERT_*(condition) << "Some message"; 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The "switch (0) case 0:" idiom is used to suppress this. 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __INTEL_COMPILER 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Use this annotation at the end of a struct/class definition to 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// prevent the compiler from optimizing away instances that are never 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// used. This is useful when all interesting logic happens inside the 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// c'tor and / or d'tor. Example: 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// struct Foo { 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Foo() { ... } 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// } GTEST_ATTRIBUTE_UNUSED_; 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Also use it after a variable or parameter declaration to tell the 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// compiler the variable/parameter does not have to be used. 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__GNUC__) && !defined(COMPILER_ICC) 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_ATTRIBUTE_UNUSED_ 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A macro to disallow operator= 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This should be used in the private: declarations for a class. 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DISALLOW_ASSIGN_(type)\ 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(type const &) 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A macro to disallow copy constructor and operator= 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This should be used in the private: declarations for a class. 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert type(type const &);\ 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_ASSIGN_(type) 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tell the compiler to warn about unused return values for functions declared 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// with this macro. The macro should be used on function declarations 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// following the argument list: 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_MUST_USE_RESULT_ 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Determine whether the compiler supports Microsoft's Structured Exception 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Handling. This is supported by several Windows compilers but generally 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// does not exist on any other system. 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_HAS_SEH 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The user didn't tell us, so we need to figure it out. 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if defined(_MSC_VER) || defined(__BORLANDC__) 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// These two compilers are known to support SEH. 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_SEH 1 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Assume no SEH. 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_SEH 0 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_SEH 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _MSC_VER 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_LINKED_AS_SHARED_LIBRARY 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_API_ __declspec(dllimport) 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# elif GTEST_CREATE_SHARED_LIBRARY 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_API_ __declspec(dllexport) 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // _MSC_VER 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef GTEST_API_ 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_API_ 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __GNUC__ 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Ask the compiler to never inline a given function. 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_NO_INLINE_ __attribute__((noinline)) 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_NO_INLINE_ 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION) 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CXXABI_H_ 1 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_CXXABI_H_ 0 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Message; 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace internal { 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A secret type that Google Test users don't know about. It has no 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// definition on purpose. Therefore it's impossible to create a 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Secret object, which is what we want. 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Secret; 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// expression is true. For example, you could use it to verify the 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// size of a static array: 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// content_type_names_incorrect_size); 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// or to make sure a struct is smaller than a certain size: 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The second argument to the macro is the name of the variable. If 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the expression is false, most compilers will issue a warning/error 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// containing the name of the variable. 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <bool> 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct CompileAssert { 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_COMPILE_ASSERT_(expr, msg) \ 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \ 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_ 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Implementation details of GTEST_COMPILE_ASSERT_: 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// elements (and thus is invalid) when the expression is false. 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - The simpler definition 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// does not work, as gcc supports variable-length arrays whose sizes 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are determined at run-time (this is gcc's extension and not part 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of the C++ standard). As a result, gcc fails to reject the 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// following code with the simple definition: 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// int foo; 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // not a compile-time constant. 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - By using the type CompileAssert<(bool(expr))>, we ensures that 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// expr is a compile-time constant. (Template arguments must be 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// determined at compile-time.) 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - The outter parentheses in CompileAssert<(bool(expr))> are necessary 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// CompileAssert<bool(expr)> 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// instead, these compilers will refuse to compile 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_COMPILE_ASSERT_(5 > 0, some_message); 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (They seem to think the ">" in "5 > 0" marks the end of the 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// template argument list.) 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// - The array size is (bool(expr) ? 1 : -1), instead of simply 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ((expr) ? 1 : -1). 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is to avoid running into a bug in MS VC 7.1, which 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This template is declared, but intentionally undefined. 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct StaticAssertTypeEqHelper; 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct StaticAssertTypeEqHelper<T, T> {}; 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ::string string; 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ::std::string string; 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_STRING 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_WSTRING 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ::wstring wstring; 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif GTEST_HAS_STD_WSTRING 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ::std::wstring wstring; 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_WSTRING 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A helper for suppressing warnings on constant condition. It just 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// returns 'condition'. 88311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ bool IsTrue(bool condition); 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines scoped_ptr. 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This implementation of scoped_ptr is PARTIAL - it only contains 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// enough stuff to satisfy Google Test's need. 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass scoped_ptr { 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef T element_type; 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~scoped_ptr() { reset(); } 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T& operator*() const { return *ptr_; } 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* operator->() const { return ptr_; } 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* get() const { return ptr_; } 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* release() { 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* const ptr = ptr_; 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptr_ = NULL; 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return ptr; 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void reset(T* p = NULL) { 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (p != ptr_) { 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete ptr_; 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptr_ = p; 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* ptr_; 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines RE. 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Regular Expression syntax. 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTEST_API_ RE { 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A copy constructor is required by the Standard to initialize object 92911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // references from r-values. 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RE(const RE& other) { Init(other.pattern()); } 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Constructs an RE from a string. 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 93811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_STRING 94011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RE(const char* regex) { Init(regex); } // NOLINT 94211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~RE(); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the string representation of the regex. 94511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* pattern() const { return pattern_; } 94611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // FullMatch(str, re) returns true iff regular expression re matches 94811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the entire str. 94911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // PartialMatch(str, re) returns true iff regular expression re 95011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // matches a substring of str (including str itself). 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TODO(wan@google.com): make FullMatch() and PartialMatch() work 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // when str contains NUL characters. 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool FullMatch(const ::std::string& str, const RE& re) { 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return FullMatch(str.c_str(), re); 95611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 95711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool PartialMatch(const ::std::string& str, const RE& re) { 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return PartialMatch(str.c_str(), re); 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool FullMatch(const ::string& str, const RE& re) { 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return FullMatch(str.c_str(), re); 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool PartialMatch(const ::string& str, const RE& re) { 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return PartialMatch(str.c_str(), re); 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_STRING 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool FullMatch(const char* str, const RE& re); 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool PartialMatch(const char* str, const RE& re); 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Init(const char* regex); 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use a const char* instead of an std::string, as Google Test used to be 97911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // used where std::string is not available. TODO(wan@google.com): change to 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // std::string. 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* pattern_; 98211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_valid_; 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_USES_POSIX_RE 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert regex_t full_regex_; // For FullMatch(). 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert regex_t partial_regex_; // For PartialMatch(). 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else // GTEST_USES_SIMPLE_RE 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* full_pattern_; // For FullMatch(); 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_ASSIGN_(RE); 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Formats a source file path and a line number as they would appear 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in an error message from the compiler used to compile this code. 100011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ ::std::string FormatFileLocation(const char* file, int line); 100111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Formats a file location for compiler-independent XML output. 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Although this function is not platform dependent, we put it next to 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// FormatFileLocation in order to contrast the two functions. 100511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int line); 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines logging utilities: 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_LOG_(severity) - logs messages at the specified severity level. The 101011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// message itself is streamed into the macro. 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LogToStderr() - directs all log messages to stderr. 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// FlushInfoLog() - flushes informational log messages. 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertenum GTestLogSeverity { 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_INFO, 101611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_WARNING, 101711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ERROR, 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FATAL 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Formats log entry severity, provides a stream object for streaming the 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// log message, and terminates the message with a newline when going out of 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// scope. 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTEST_API_ GTestLog { 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTestLog(GTestLogSeverity severity, const char* file, int line); 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~GTestLog(); 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::ostream& GetStream() { return ::std::cerr; } 103211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 103411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const GTestLogSeverity severity_; 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_LOG_(severity) \ 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __FILE__, __LINE__).GetStream() 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void LogToStderr() {} 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void FlushInfoLog() { fflush(NULL); } 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// INTERNAL IMPLEMENTATION - DO NOT USE. 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 104811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is not satisfied. 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Synopsys: 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_CHECK_(boolean_condition); 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// or 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_CHECK_(boolean_condition) << "Additional message"; 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This checks the condition and if the condition is not satisfied 105611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// it prints message about the condition violation, including the 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// condition itself, plus additional message streamed into it, if any, 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and then it aborts the program. It aborts the program irrespective of 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// whether it is built in the debug mode or not. 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_CHECK_(condition) \ 106111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (::testing::internal::IsTrue(condition)) \ 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; \ 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else \ 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// An all-mode assert to verify that the given POSIX-style function 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// call returns 0 (indicating success). Known limitation: this 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// doesn't expand to a balanced 'if' statement, so enclose the macro 107011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in {} if you need to use it as the only statement in an 'if' 107111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// branch. 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (const int gtest_error = (posix_call)) \ 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << gtest_error 107611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Use ImplicitCast_ as a safe version of static_cast for upcasting in 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// const Foo*). When you use ImplicitCast_, the compiler checks that 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the cast is safe. Such explicit ImplicitCast_s are necessary in 108311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// surprisingly many situations where C++ demands an exact type match 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// instead of an argument type convertable to a target type. 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The syntax for using ImplicitCast_ is the same as for static_cast: 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ImplicitCast_<ToType>(expr) 108911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 109011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ImplicitCast_ would have been part of the C++ standard library, 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// but the proposal was submitted too late. It will probably make 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// its way into the language in the future. 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This relatively ugly name is intentional. It prevents clashes with 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// similar functions users may have (e.g., implicit_cast). The internal 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// namespace alone is not enough because the function can be found by ADL. 109711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate<typename To> 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline To ImplicitCast_(To x) { return x; } 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// When you upcast (that is, cast a pointer from type Foo to type 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// always succeed. When you downcast (that is, cast a pointer from 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// how do you know the pointer is really of type SubclassOfFoo? It 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// when you downcast, you should use this macro. In debug mode, we 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use dynamic_cast<> to double-check the downcast is legal (we die 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if it's not). In normal mode, we do the efficient static_cast<> 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// instead. Thus, it's important to test in debug mode to make sure 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the cast is legal! 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is the only place in the code we should use dynamic_cast<>. 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// In particular, you SHOULDN'T be using dynamic_cast<> in order to 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// do RTTI (eg code like this: 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// You should design the code some other way not to need this. 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This relatively ugly name is intentional. It prevents clashes with 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// similar functions users may have (e.g., down_cast). The internal 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// namespace alone is not enough because the function can be found by ADL. 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate<typename To, typename From> // use like this: DownCast_<T*>(foo); 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline To DownCast_(From* f) { // so we only accept pointers 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Ensures that To is a sub-type of From *. This test is here only 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // for compile-time type checking, and has no overhead in an 112511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // optimized build at run-time, as it will be optimized away 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // completely. 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (false) { 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const To to = NULL; 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::testing::internal::ImplicitCast_<From*>(to); 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_RTTI 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // RTTI: debug mode only! 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL); 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<To>(f); 113711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Downcasts the pointer of type Base to Derived. 114011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Derived must be a subclass of Base. The parameter MUST 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// point to a class of type Derived, not any subclass of it. 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// When RTTI is available, the function performs a runtime 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// check to enforce this. 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class Derived, class Base> 114511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertDerived* CheckedDowncastToActualType(Base* base) { 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_RTTI 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(typeid(*base) == typeid(Derived)); 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return dynamic_cast<Derived*>(base); // NOLINT 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<Derived*>(base); // Poor man's downcast. 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STREAM_REDIRECTION 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines the stderr capturer: 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// CaptureStdout - starts capturing stdout. 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetCapturedStdout - stops capturing stdout and returns the captured string. 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// CaptureStderr - starts capturing stderr. 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GetCapturedStderr - stops capturing stderr and returns the captured string. 116111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 116211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ void CaptureStdout(); 116311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string GetCapturedStdout(); 116411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ void CaptureStderr(); 116511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ std::string GetCapturedStderr(); 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STREAM_REDIRECTION 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_DEATH_TEST 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst ::std::vector<testing::internal::string>& GetInjectableArgvs(); 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid SetInjectableArgvs(const ::std::vector<testing::internal::string>* 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert new_argvs); 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A copy of all command line arguments. Set by InitGoogleTest(). 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertextern ::std::vector<testing::internal::string> g_argvs; 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_DEATH_TEST 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines synchronization primitives. 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_PTHREAD 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sleeps for (roughly) n milli-seconds. This function is only for 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// testing Google Test's own constructs. Don't use it in user tests, 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// either directly or indirectly. 118811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void SleepMilliseconds(int n) { 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const timespec time = { 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 0, // 0 seconds. 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert n * 1000L * 1000L, // And n ms. 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 119311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert nanosleep(&time, NULL); 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Allows a controller thread to pause execution of newly created 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// threads until notified. Instances of this class must be created 119811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and destroyed in the controller thread. 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class is only for testing Google Test's own constructs. Do not 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use it in user tests, either directly or indirectly. 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Notification { 120311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Notification() : notified_(false) { 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~Notification() { 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_destroy(&mutex_); 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Notifies all threads created with this notification to start. Must 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // be called from the controller thread. 121311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Notify() { 121411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_lock(&mutex_); 121511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert notified_ = true; 121611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_unlock(&mutex_); 121711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 121811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Blocks until the controller thread notifies. Must be called from a test 122011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // thread. 122111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void WaitForNotification() { 122211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (;;) { 122311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_lock(&mutex_); 122411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool notified = notified_; 122511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_unlock(&mutex_); 122611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (notified) 122711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 122811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SleepMilliseconds(10); 122911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 123011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 123111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 123311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_t mutex_; 123411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool notified_; 123511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 123711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 123811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. 124011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Consequently, it cannot select a correct instantiation of ThreadWithParam 124111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in order to call its Run(). Introducing ThreadWithParamBase as a 124211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// non-templated base class for ThreadWithParam allows us to bypass this 124311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// problem. 124411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ThreadWithParamBase { 124511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 124611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~ThreadWithParamBase() {} 124711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Run() = 0; 124811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 124911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pthread_create() accepts a pointer to a function type with the C linkage. 125111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// According to the Standard (7.5/1), function types with different linkages 125211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are different even if they are otherwise identical. Some compilers (for 125311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// example, SunStudio) treat them as different types. Since class methods 125411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// cannot be defined with C-linkage we need to define a free C-function to 125511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pass into pthread_create(). 125611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertextern "C" inline void* ThreadFuncWithCLinkage(void* thread) { 125711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<ThreadWithParamBase*>(thread)->Run(); 125811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return NULL; 125911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 126011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Helper class for testing Google Test's multi-threading constructs. 126211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// To use it, write: 126311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 126411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// void ThreadFunc(int param) { /* Do things with param */ } 126511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Notification thread_can_start; 126611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ... 126711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // The thread_can_start parameter is optional; you can supply NULL. 126811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); 126911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// thread_can_start.Notify(); 127011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 127111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// These classes are only for testing Google Test's own constructs. Do 127211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// not use them in user tests, either directly or indirectly. 127311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 127411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ThreadWithParam : public ThreadWithParamBase { 127511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 127611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef void (*UserThreadFunc)(T); 127711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadWithParam( 127911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UserThreadFunc func, T param, Notification* thread_can_start) 128011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : func_(func), 128111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert param_(param), 128211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert thread_can_start_(thread_can_start), 128311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert finished_(false) { 128411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadWithParamBase* const base = this; 128511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The thread can be created only after all fields except thread_ 128611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // have been initialized. 128711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_( 128811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); 128911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 129011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~ThreadWithParam() { Join(); } 129111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Join() { 129311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!finished_) { 129411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); 129511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert finished_ = true; 129611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 129711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 129811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Run() { 130011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (thread_can_start_ != NULL) 130111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert thread_can_start_->WaitForNotification(); 130211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert func_(param_); 130311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 130411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 130611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const UserThreadFunc func_; // User-supplied thread function. 130711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T param_; // User-supplied parameter to the thread function. 130811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // When non-NULL, used to block execution until the controller thread 130911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // notifies. 131011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Notification* const thread_can_start_; 131111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool finished_; // true iff we know that the thread function has finished. 131211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_t thread_; // The native thread object. 131311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 131511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 131611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MutexBase and Mutex implement mutex on pthreads-based platforms. They 131811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are used in conjunction with class MutexLock: 131911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 132011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Mutex mutex; 132111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ... 132211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end 132311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // of the current scope. 132411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 132511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MutexBase implements behavior for both statically and dynamically 132611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// allocated mutexes. Do not use MutexBase directly. Instead, write 132711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the following to define a static mutex: 132811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 132911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); 133011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 133111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// You can forward declare a static mutex like this: 133211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 133311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); 133411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 133511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// To create a dynamic mutex, just define an object of type Mutex. 133611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MutexBase { 133711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 133811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Acquires this mutex. 133911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Lock() { 134011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); 134111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert owner_ = pthread_self(); 134211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert has_owner_ = true; 134311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 134411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Releases this mutex. 134611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Unlock() { 134711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Since the lock is being released the owner_ field should no longer be 134811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // considered valid. We don't protect writing to has_owner_ here, as it's 134911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the caller's responsibility to ensure that the current thread holds the 135011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // mutex when this is called. 135111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert has_owner_ = false; 135211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); 135311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 135411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Does nothing if the current thread holds the mutex. Otherwise, crashes 135611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // with high probability. 135711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void AssertHeld() const { 135811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self())) 135911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "The current thread is not holding the mutex @" << this; 136011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 136111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A static mutex may be used before main() is entered. It may even 136311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // be used before the dynamic initialization stage. Therefore we 136411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // must be able to initialize a static mutex object at link time. 136511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This means MutexBase has to be a POD and its member variables 136611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // have to be public. 136711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 136811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_mutex_t mutex_; // The underlying pthread mutex. 136911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // has_owner_ indicates whether the owner_ field below contains a valid thread 137011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All 137111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // accesses to the owner_ field should be protected by a check of this field. 137211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // An alternative might be to memset() owner_ to all zeros, but there's no 137311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // guarantee that a zero'd pthread_t is necessarily invalid or even different 137411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // from pthread_self(). 137511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool has_owner_; 137611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_t owner_; // The thread holding the mutex. 137711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 137811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Forward-declares a static mutex. 138011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 138111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert extern ::testing::internal::MutexBase mutex 138211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 138311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Defines and statically (i.e. at link time) initializes a static mutex. 138411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The initialization list here does not explicitly initialize each field, 138511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// instead relying on default initialization for the unspecified fields. In 138611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// particular, the owner_ field (a pthread_t) is not explicitly initialized. 138711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This allows initialization to work whether pthread_t is a scalar or struct. 138811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The flag -Wmissing-field-initializers must not be specified for this to work. 138911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 139011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false } 139111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The Mutex class can only be used for mutexes created at runtime. It 139311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// shares its API with MutexBase otherwise. 139411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Mutex : public MutexBase { 139511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 139611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Mutex() { 139711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 139811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert has_owner_ = false; 139911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 140011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~Mutex() { 140111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); 140211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 140311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 140511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 140611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 140711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We cannot name this class MutexLock as the ctor declaration would 140911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// conflict with a macro named MutexLock, which is defined on some 141011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// platforms. Hence the typedef trick below. 141111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTestMutexLock { 141211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 141311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit GTestMutexLock(MutexBase* mutex) 141411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : mutex_(mutex) { mutex_->Lock(); } 141511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~GTestMutexLock() { mutex_->Unlock(); } 141711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 141911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MutexBase* const mutex_; 142011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 142211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 142311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef GTestMutexLock MutexLock; 142511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Helpers for ThreadLocal. 142711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pthread_key_create() requires DeleteThreadLocalValue() to have 142911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// C-linkage. Therefore it cannot be templatized to access 143011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ThreadLocal<T>. Hence the need for class 143111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ThreadLocalValueHolderBase. 143211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ThreadLocalValueHolderBase { 143311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 143411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~ThreadLocalValueHolderBase() {} 143511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 143611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 143711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Called by pthread to delete thread-local data stored by 143811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pthread_setspecific(). 143911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertextern "C" inline void DeleteThreadLocalValue(void* value_holder) { 144011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete static_cast<ThreadLocalValueHolderBase*>(value_holder); 144111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 144211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Implements thread-local storage on pthreads-based systems. 144411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 144511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // Thread 1 144611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ThreadLocal<int> tl(100); // 100 is the default value for each thread. 144711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 144811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // Thread 2 144911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tl.set(150); // Changes the value for thread 2 only. 145011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT_EQ(150, tl.get()); 145111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 145211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// // Thread 1 145311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. 145411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tl.set(200); 145511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT_EQ(200, tl.get()); 145611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 145711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The template type argument T must have a public copy constructor. 145811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// In addition, the default ThreadLocal constructor requires T to have 145911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// a public default constructor. 146011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 146111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// An object managed for a thread by a ThreadLocal instance is deleted 146211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// when the thread exits. Or, if the ThreadLocal instance dies in 146311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that thread, when the ThreadLocal dies. It's the user's 146411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// responsibility to ensure that all other threads using a ThreadLocal 146511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// have exited when it dies, or the per-thread objects for those 146611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// threads will not be deleted. 146711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 146811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test only uses global ThreadLocal objects. That means they 146911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// will die after main() has returned. Therefore, no per-thread 147011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// object managed by Google Test will be leaked as long as all threads 147111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// using Google Test have exited when main() returns. 147211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 147311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ThreadLocal { 147411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 147511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadLocal() : key_(CreateKey()), 147611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default_() {} 147711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit ThreadLocal(const T& value) : key_(CreateKey()), 147811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default_(value) {} 147911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~ThreadLocal() { 148111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Destroys the managed object for the current thread, if any. 148211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeleteThreadLocalValue(pthread_getspecific(key_)); 148311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Releases resources associated with the key. This will *not* 148511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // delete managed objects for other threads. 148611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); 148711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 148811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* pointer() { return GetOrCreateValue(); } 149011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T* pointer() const { return GetOrCreateValue(); } 149111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T& get() const { return *pointer(); } 149211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set(const T& value) { *pointer() = value; } 149311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 149411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 149511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Holds a value of type T. 149611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert class ValueHolder : public ThreadLocalValueHolderBase { 149711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 149811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit ValueHolder(const T& value) : value_(value) {} 149911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* pointer() { return &value_; } 150111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 150311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T value_; 150411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 150511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 150611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static pthread_key_t CreateKey() { 150811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_key_t key; 150911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // When a thread exits, DeleteThreadLocalValue() will be called on 151011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the object managed for that thread. 151111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_( 151211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_key_create(&key, &DeleteThreadLocalValue)); 151311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return key; 151411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 151511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 151611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* GetOrCreateValue() const { 151711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadLocalValueHolderBase* const holder = 151811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); 151911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (holder != NULL) { 152011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); 152111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 152211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ValueHolder* const new_holder = new ValueHolder(default_); 152411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadLocalValueHolderBase* const holder_base = new_holder; 152511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); 152611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return new_holder->pointer(); 152711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 152811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A key pthreads uses for looking up per-thread values. 153011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const pthread_key_t key_; 153111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T default_; // The default value for each thread. 153211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 153411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 153511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_IS_THREADSAFE 1 153711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else // GTEST_HAS_PTHREAD 153911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 154011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A dummy implementation of synchronization primitives (mutex, lock, 154111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and thread-local variable). Necessary for compiling Google Test where 154211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mutex is not supported - using Google Test in multiple threads is not 154311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// supported on such platforms. 154411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 154511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Mutex { 154611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 154711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Mutex() {} 154811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Lock() {} 154911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Unlock() {} 155011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void AssertHeld() const {} 155111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 155211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 155311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 155411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert extern ::testing::internal::Mutex mutex 155511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 155611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 155711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 155811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTestMutexLock { 155911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 156011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit GTestMutexLock(Mutex*) {} // NOLINT 156111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 156211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef GTestMutexLock MutexLock; 156411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 156611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ThreadLocal { 156711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 156811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadLocal() : value_() {} 156911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit ThreadLocal(const T& value) : value_(value) {} 157011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T* pointer() { return &value_; } 157111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T* pointer() const { return &value_; } 157211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T& get() const { return value_; } 157311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void set(const T& value) { value_ = value; } 157411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 157511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert T value_; 157611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 157711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 157811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The above synchronization primitives have dummy implementations. 157911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Therefore Google Test is not thread-safe. 158011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_IS_THREADSAFE 0 158111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 158211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_PTHREAD 158311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 158411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the number of threads running in the process, or 0 to indicate that 158511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// we cannot detect it. 158611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ size_t GetThreadCount(); 158711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 158811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Passing non-POD classes through ellipsis (...) crashes the ARM 158911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// compiler and generates a warning in Sun Studio. The Nokia Symbian 159011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and the IBM XL C/C++ compiler try to instantiate a copy constructor 159111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// for objects passed through ellipsis (...), failing for uncopyable 159211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// objects. We define this to ensure that only POD is passed through 159311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ellipsis on these systems. 159411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 159511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We lose support for NULL detection where the compiler doesn't like 159611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// passing non-POD classes through ellipsis (...). 159711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_ELLIPSIS_NEEDS_POD_ 1 159811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 159911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_CAN_COMPARE_NULL 1 160011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 160111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 160211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 160311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// const T& and const T* in a function template. These compilers 160411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// _can_ decide between class template specializations for T and T*, 160511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// so a tr1::type_traits-like is_pointer works. 160611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 160711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_NEEDS_IS_POINTER_ 1 160811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 160911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <bool bool_value> 161111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct bool_constant { 161211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef bool_constant<bool_value> type; 161311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const bool value = bool_value; 161411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 161511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <bool bool_value> const bool bool_constant<bool_value>::value; 161611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef bool_constant<false> false_type; 161811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef bool_constant<true> true_type; 161911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 162111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct is_pointer : public false_type {}; 162211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 162411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct is_pointer<T*> : public true_type {}; 162511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename Iterator> 162711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct IteratorTraits { 162811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename Iterator::value_type value_type; 162911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 163011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 163111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 163211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct IteratorTraits<T*> { 163311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef T value_type; 163411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 163511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 163611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 163711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct IteratorTraits<const T*> { 163811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef T value_type; 163911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 164011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 164111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 164211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_PATH_SEP_ "\\" 164311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_ALT_PATH_SEP_ 1 164411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The biggest signed integer type the compiler supports. 164511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef __int64 BiggestInt; 164611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 164711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_PATH_SEP_ "/" 164811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_HAS_ALT_PATH_SEP_ 0 164911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef long long BiggestInt; // NOLINT 165011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 165111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Utilities for char. 165311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// isspace(int ch) and friends accept an unsigned char or EOF. char 165511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// may be signed, depending on the compiler (or compiler flags). 165611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Therefore we need to cast a char to unsigned char before calling 165711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// isspace(), etc. 165811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsAlpha(char ch) { 166011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isalpha(static_cast<unsigned char>(ch)) != 0; 166111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 166211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsAlNum(char ch) { 166311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isalnum(static_cast<unsigned char>(ch)) != 0; 166411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 166511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsDigit(char ch) { 166611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isdigit(static_cast<unsigned char>(ch)) != 0; 166711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 166811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsLower(char ch) { 166911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return islower(static_cast<unsigned char>(ch)) != 0; 167011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 167111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsSpace(char ch) { 167211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isspace(static_cast<unsigned char>(ch)) != 0; 167311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 167411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsUpper(char ch) { 167511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isupper(static_cast<unsigned char>(ch)) != 0; 167611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 167711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsXDigit(char ch) { 167811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return isxdigit(static_cast<unsigned char>(ch)) != 0; 167911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 168011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsXDigit(wchar_t ch) { 168111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const unsigned char low_byte = static_cast<unsigned char>(ch); 168211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return ch == low_byte && isxdigit(low_byte) != 0; 168311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 168411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline char ToLower(char ch) { 168611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<char>(tolower(static_cast<unsigned char>(ch))); 168711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 168811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline char ToUpper(char ch) { 168911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<char>(toupper(static_cast<unsigned char>(ch))); 169011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 169111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 169211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The testing::internal::posix namespace holds wrappers for common 169311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// POSIX functions. These wrappers hide the differences between 169411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Windows/MSVC and POSIX systems. Since some compilers define these 169511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// standard functions as macros, the wrapper cannot have the same name 169611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as the wrapped function. 169711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 169811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace posix { 169911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Functions with a different name on Windows. 170111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 170311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef struct _stat StatStruct; 170511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef __BORLANDC__ 170711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int IsATTY(int fd) { return isatty(fd); } 170811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int StrCaseCmp(const char* s1, const char* s2) { 170911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return stricmp(s1, s2); 171011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 171111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline char* StrDup(const char* src) { return strdup(src); } 171211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else // !__BORLANDC__ 171311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS_MOBILE 171411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int IsATTY(int /* fd */) { return 0; } 171511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 171611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int IsATTY(int fd) { return _isatty(fd); } 171711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS_MOBILE 171811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int StrCaseCmp(const char* s1, const char* s2) { 171911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _stricmp(s1, s2); 172011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 172111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline char* StrDup(const char* src) { return _strdup(src); } 172211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // __BORLANDC__ 172311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 172411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS_MOBILE 172511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 172611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 172711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// time and thus not defined there. 172811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 172911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int FileNo(FILE* file) { return _fileno(file); } 173011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 173111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int RmDir(const char* dir) { return _rmdir(dir); } 173211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsDir(const StatStruct& st) { 173311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (_S_IFDIR & st.st_mode) != 0; 173411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 173511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS_MOBILE 173611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 173711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 173811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 173911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef struct stat StatStruct; 174011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 174111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int FileNo(FILE* file) { return fileno(file); } 174211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int IsATTY(int fd) { return isatty(fd); } 174311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 174411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int StrCaseCmp(const char* s1, const char* s2) { 174511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return strcasecmp(s1, s2); 174611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 174711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline char* StrDup(const char* src) { return strdup(src); } 174811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int RmDir(const char* dir) { return rmdir(dir); } 174911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 175011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 175111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 175211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 175311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Functions deprecated by MSVC 8.0. 175411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 175511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _MSC_VER 175611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Temporarily disable warning 4996 (deprecated function). 175711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(push) 175811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(disable:4996) 175911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 176011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 176111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline const char* StrNCpy(char* dest, const char* src, size_t n) { 176211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return strncpy(dest, src, n); 176311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 176411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 176511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 176611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// StrError() aren't needed on Windows CE at this time and thus not 176711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// defined there. 176811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 176911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 177011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int ChDir(const char* dir) { return chdir(dir); } 177111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 177211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline FILE* FOpen(const char* path, const char* mode) { 177311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return fopen(path, mode); 177411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 177511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 177611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 177711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return freopen(path, mode, stream); 177811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 177911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 178011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 178111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int FClose(FILE* fp) { return fclose(fp); } 178211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 178311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int Read(int fd, void* buf, unsigned int count) { 178411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<int>(read(fd, buf, count)); 178511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 178611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int Write(int fd, const void* buf, unsigned int count) { 178711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return static_cast<int>(write(fd, buf, count)); 178811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 178911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline int Close(int fd) { return close(fd); } 179011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline const char* StrError(int errnum) { return strerror(errnum); } 179111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 179211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline const char* GetEnv(const char* name) { 179311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS_MOBILE 179411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We are on Windows CE, which has no environment variables. 179511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return NULL; 179611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 179711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Environment variables which we programmatically clear will be set to the 179811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // empty string rather than unset (NULL). Handle that case. 179911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* const env = getenv(name); 180011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (env != NULL && env[0] != '\0') ? env : NULL; 180111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 180211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return getenv(name); 180311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 180411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 180511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 180611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _MSC_VER 180711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(pop) // Restores the warning state. 180811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 180911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 181011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS_MOBILE 181111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Windows CE has no C library. The abort() function is used in 181211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// several places in Google Test. This implementation provides a reasonable 181311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// imitation of standard behaviour. 181411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid Abort(); 181511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(__ANDROID__) && defined(__mips__) 181611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Work-around broken abort() on Android/MIPS 181711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void Abort() { fflush(NULL); exit(1); } 181811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 181911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline void Abort() { abort(); } 182011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS_MOBILE 182111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 182211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace posix 182311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 182411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MSVC "deprecates" snprintf and issues warnings wherever it is used. In 182511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// order to avoid these warnings, we need to use _snprintf or _snprintf_s on 182611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate 182711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function in order to achieve that. We use macro definition here because 182811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// snprintf is a variadic function. 182911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 183011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MSVC 2005 and above support variadic macros. 183111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_SNPRINTF_(buffer, size, format, ...) \ 183211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _snprintf_s(buffer, size, size, format, __VA_ARGS__) 183311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(_MSC_VER) 183411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't 183511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// complain about _snprintf. 183611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_SNPRINTF_ _snprintf 183711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 183811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_SNPRINTF_ snprintf 183911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 184011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 184111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The maximum number a BiggestInt can represent. This definition 184211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// works no matter BiggestInt is represented in one's complement or 184311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// two's complement. 184411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 184511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We cannot rely on numeric_limits in STL, as __int64 and long long 184611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are not part of standard C++ and numeric_limits doesn't need to be 184711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// defined for them. 184811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst BiggestInt kMaxBiggestInt = 184911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 185011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 185111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This template class serves as a compile-time function from size to 185211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// type. It maps a size in bytes to a primitive type with that 185311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// size. e.g. 185411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 185511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TypeWithSize<4>::UInt 185611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 185711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is typedef-ed to be unsigned int (unsigned integer made up of 4 185811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// bytes). 185911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 186011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Such functionality should belong to STL, but I cannot find it 186111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// there. 186211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 186311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test uses this class in the implementation of floating-point 186411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// comparison. 186511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 186611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// For now it only handles UInt (unsigned int) as that's all Google Test 186711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// needs. Other types can be easily added in the future if need 186811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// arises. 186911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <size_t size> 187011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TypeWithSize { 187111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 187211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This prevents the user from using TypeWithSize<N> with incorrect 187311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // values of N. 187411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef void UInt; 187511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 187611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 187711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The specialization for size 4. 187811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <> 187911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TypeWithSize<4> { 188011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 188111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // unsigned int has size 4 in both gcc and MSVC. 188211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 188311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // As base/basictypes.h doesn't compile on Windows, we cannot use 188411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // uint32, uint64, and etc here. 188511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int Int; 188611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef unsigned int UInt; 188711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 188811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 188911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The specialization for size 8. 189011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <> 189111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TypeWithSize<8> { 189211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 189311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 189411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef __int64 Int; 189511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef unsigned __int64 UInt; 189611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 189711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef long long Int; // NOLINT 189811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef unsigned long long UInt; // NOLINT 189911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 190011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 190111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 190211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Integer types of known sizes. 190311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TypeWithSize<4>::Int Int32; 190411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TypeWithSize<4>::UInt UInt32; 190511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TypeWithSize<8>::Int Int64; 190611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TypeWithSize<8>::UInt UInt64; 190711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 190811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 190911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Utilities for command line flags and environment variables. 191011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 191111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macro for referencing flags. 191211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_FLAG(name) FLAGS_gtest_##name 191311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 191411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macros for declaring flags. 191511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 191611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DECLARE_int32_(name) \ 191711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 191811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DECLARE_string_(name) \ 191911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_API_ extern ::std::string GTEST_FLAG(name) 192011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 192111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Macros for defining flags. 192211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DEFINE_bool_(name, default_val, doc) \ 192311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_API_ bool GTEST_FLAG(name) = (default_val) 192411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DEFINE_int32_(name, default_val, doc) \ 192511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 192611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_DEFINE_string_(name, default_val, doc) \ 192711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) 192811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 192911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Thread annotations 193011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) 193111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_LOCK_EXCLUDED_(locks) 193211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 193311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parses 'str' for a 32-bit signed integer. If successful, writes the result 193411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to *value and returns true; otherwise leaves *value unchanged and returns 193511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// false. 193611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TODO(chandlerc): Find a better way to refactor flag and environment parsing 193711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 193811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function. 193911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool ParseInt32(const Message& src_text, const char* str, Int32* value); 194011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 194111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Parses a bool/Int32/string from the environment variable 194211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// corresponding to the given Google Test flag. 194311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool BoolFromGTestEnv(const char* flag, bool default_val); 194411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 194511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* StringFromGTestEnv(const char* flag, const char* default_val); 194611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 194711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace internal 194811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 194911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 195011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1951