1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2005, Google Inc. 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Authors: wan@google.com (Zhanyong Wan) 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Low-level types and utilities for porting Google Test to various 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// platforms. They are subject to change without notice. DO NOT USE 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEM IN USER CODE. 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user can define the following macros in the build script to 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// control Google Test's behavior. If the user doesn't define a macro 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in this list, Google Test will define it. 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is/isn't available. 450ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions 460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// are enabled. 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is/isn't available (some systems define 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::string, which is different to std::string). 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is/isn't available (some systems define 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ::wstring, which is different to std::wstring). 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is/isn't available. 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// enabled. 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// std::wstring does/doesn't work (Google Test can 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be used where std::wstring is unavailable). 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is/isn't available. 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// compiler supports Microsoft's "Structured 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Exception Handling". 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test's own tr1 tuple implementation should be 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// used. Unused when the user sets 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_TR1_TUPLE to 0. 690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_LINKED_AS_SHARED_LIBRARY 700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// - Define to 1 when compiling tests that use 710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Google Test as a shared library (known as 720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// DLL on Windows). 730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_CREATE_SHARED_LIBRARY 740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// - Define to 1 when compiling Google Test itself 750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// as a shared library. 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This header defines the following utilities: 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros indicating the current platform (defined to 1 if compiled on 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the given platform; otherwise undefined): 810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_OS_AIX - IBM AIX 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_CYGWIN - Cygwin 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_LINUX - Linux 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_MAC - Mac OS X 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_SOLARIS - Sun Solaris 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_SYMBIAN - Symbian 87d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 88d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 89d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// GTEST_OS_WINDOWS_MINGW - MinGW 900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_OS_ZOS - z/OS 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// most stable support. Since core members of the Google Test project 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// don't have access to other platforms, support for them may be less 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// stable. If you notice any problems on your platform, please notify 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// googletestframework@googlegroups.com (patches for fixing them are 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// even more welcome!). 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Note that it is possible that none of the GTEST_OS_* macros are defined. 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros indicating available Google Test features (defined to 1 if 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the corresponding feature is supported; otherwise undefined): 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// tests) 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_DEATH_TEST - death tests 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_PARAM_TEST - value-parameterized tests 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_TYPED_TEST - typed tests 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_USES_SIMPLE_RE - our own simple regex is used; 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the above two are mutually exclusive. 1130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for basic C++ coding: 116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// variable don't have to be used. 1190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_DISALLOW_ASSIGN_ - disables operator=. 120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Synchronization: 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Mutex, MutexLock, ThreadLocal, GetThreadCount() 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - synchronization primitives. 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// synchronization primitives have real implementations 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and Google Test is thread-safe; or 0 otherwise. 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Template meta programming: 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Smart pointers: 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// scoped_ptr - as in TR2. 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Regular expressions: 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// RE - a simple regular expression class using the POSIX 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Extended Regular Expression syntax. Not available on 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Windows. 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Logging: 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_LOG_() - logs messages at the specified severity level. 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LogToStderr() - directs all log messages to stderr. 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FlushInfoLog() - flushes informational log messages. 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Stdout and stderr capturing: 1470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// CaptureStdout() - starts capturing stdout. 1480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GetCapturedStdout() - stops capturing stdout and returns the captured 1490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// string. 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CaptureStderr() - starts capturing stderr. 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GetCapturedStderr() - stops capturing stderr and returns the captured 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// string. 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Integer types: 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TypeWithSize - maps an integer to a int type. 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Int32, UInt32, Int64, UInt64, TimeInMillis 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - integers of known sizes. 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// BiggestInt - the biggest signed integer type. 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Command-line utilities: 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_FLAG() - references a flag. 162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_DECLARE_*() - declares a flag. 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_DEFINE_*() - defines a flag. 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GetArgvs() - returns the command line as a vector of strings. 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Environment variable utilities: 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GetEnv() - gets the value of an environment variable. 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// BoolFromGTestEnv() - parses a bool environment variable. 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Int32FromGTestEnv() - parses an Int32 environment variable. 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StringFromGTestEnv() - parses a string environment variable. 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stddef.h> // For ptrdiff_t 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdlib.h> 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdio.h> 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <string.h> 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef _WIN32_WCE 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <sys/stat.h> 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // !_WIN32_WCE 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <iostream> // NOLINT 1810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <sstream> // NOLINT 1820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <string> // NOLINT 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_FLAG_PREFIX_ "gtest_" 1860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_FLAG_PREFIX_DASH_ "gtest-" 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_NAME_ "Google Test" 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines the version of gcc that is used to compile this. 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __GNUC__ 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 40302 means version 4.3.2. 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_GCC_VER_ \ 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // __GNUC__ 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines the platform on which Google Test is compiled. 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __CYGWIN__ 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_CYGWIN 1 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined __SYMBIAN32__ 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_SYMBIAN 1 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined _WIN32 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_WINDOWS 1 205d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifdef _WIN32_WCE 206d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GTEST_OS_WINDOWS_MOBILE 1 207d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#elif defined(__MINGW__) || defined(__MINGW32__) 208d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GTEST_OS_WINDOWS_MINGW 1 209d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#else 210d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GTEST_OS_WINDOWS_DESKTOP 1 211d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // _WIN32_WCE 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined __APPLE__ 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_MAC 1 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined __linux__ 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_LINUX 1 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined __MVS__ 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_ZOS 1 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined(__sun) && defined(__SVR4) 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_OS_SOLARIS 1 2200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(_AIX) 2210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_OS_AIX 1 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // __CYGWIN__ 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \ 2250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_OS_SOLARIS || GTEST_OS_AIX 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// On some platforms, <regex.h> needs someone to define size_t, and 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// won't compile otherwise. We can #include it here as we already 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// included <stdlib.h>, which is guaranteed to define size_t through 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// <stddef.h>. 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <regex.h> // NOLINT 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <strings.h> // NOLINT 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <sys/types.h> // NOLINT 2340ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <time.h> // NOLINT 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <unistd.h> // NOLINT 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_USES_POSIX_RE 1 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif GTEST_OS_WINDOWS 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 241d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if !GTEST_OS_WINDOWS_MOBILE 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <direct.h> // NOLINT 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <io.h> // NOLINT 244d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// <regex.h> is not available on Windows. Use our own simple regex 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implementation instead. 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_USES_SIMPLE_RE 1 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// <regex.h> may not be available on this platform. Use our own 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// simple regex implementation instead. 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_USES_SIMPLE_RE 1 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || 2570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS || GTEST_OS_AIX 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#ifndef GTEST_HAS_EXCEPTIONS 2600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// The user didn't tell us whether exceptions are enabled, so we need 2610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// to figure it out. 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(_MSC_VER) || defined(__BORLANDC__) 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// macro to enable exceptions, so we'll do the same. 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Assumes that exceptions are enabled by default. 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef _HAS_EXCEPTIONS 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define _HAS_EXCEPTIONS 1 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // _HAS_EXCEPTIONS 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 2700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__GNUC__) && __EXCEPTIONS 2710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 2720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_EXCEPTIONS 1 2730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__SUNPRO_CC) 2740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Sun Pro CC supports exceptions. However, there is no compile-time way of 2750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// detecting whether they are enabled or not. Therefore, we assume that 2760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// they are enabled unless the user tells us otherwise. 2770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_EXCEPTIONS 1 2780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__IBMCPP__) && __EXCEPTIONS 2790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_EXCEPTIONS 1 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 2820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// For other compilers, we assume exceptions are disabled to be 2830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// conservative. 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_EXCEPTIONS 0 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // defined(_MSC_VER) || defined(__BORLANDC__) 2860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // GTEST_HAS_EXCEPTIONS 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2880ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if !defined(GTEST_HAS_STD_STRING) 2890ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Even though we don't use this macro any longer, we keep it in case 2900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// some clients still depend on it. 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_STD_STRING 1 2920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif !GTEST_HAS_STD_STRING 2930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// The user told us that ::std::string isn't available. 2940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#error "Google Test cannot be used where ::std::string isn't available." 2950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // !defined(GTEST_HAS_STD_STRING) 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_GLOBAL_STRING 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us whether ::string is available, so we need 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to figure it out. 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_GLOBAL_STRING 0 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_STRING 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_STD_WSTRING 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us whether ::std::wstring is available, so we need 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to figure it out. 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is available. 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Cygwin 1.5 and below doesn't support ::std::wstring. 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Cygwin 1.7 might add wstring support; this should be updated when clear. 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Solaris' libc++ doesn't support it either. 3140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_STD_WSTRING 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_GLOBAL_WSTRING 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us whether ::wstring is available, so we need 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to figure it out. 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_GLOBAL_WSTRING \ 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_WSTRING 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether RTTI is available. 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_RTTI 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us whether RTTI is enabled, so we need to 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// figure it out. 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 1 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 0 3360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 3390ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 3400ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __GXX_RTTI 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 1 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 0 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // __GXX_RTTI 3460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 3470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if 3480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// both the typeid and dynamic_cast features are present. 3490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 3500ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 3510ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#ifdef __RTTI_ALL__ 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 1 3530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#else 3540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_RTTI 0 3550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 3590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// For all other compilers, we assume RTTI is enabled. 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_RTTI 1 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // _MSC_VER 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_RTTI 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 3660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// It's this header's responsibility to #include <typeinfo> when RTTI 3670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// is enabled. 3680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_RTTI 3690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <typeinfo> 3700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 3710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 3720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Determines whether Google Test can use the pthreads library. 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_PTHREAD 3740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// The user didn't tell us explicitly, so we assume pthreads support is 3750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// available on Linux and Mac. 3760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 3770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 3780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// to your compiler flags. 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PTHREAD 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether Google Test can use tr1/tuple. You can define 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this macro to 0 to prevent Google Test from using tuple (any 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// feature depending on tuple with be disabled in this mode). 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_TR1_TUPLE 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us not to do it, so we assume it's OK. 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_TR1_TUPLE 1 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_TR1_TUPLE 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether Google Test's own tr1 tuple implementation 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// should be used. 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_USE_OWN_TR1_TUPLE 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us, so we need to figure it out. 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 3950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// We use our own TR1 tuple if we aren't sure the user has an 3960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// implementation of it already. At this time, GCC 4.0.0+ and MSVC 3970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 2010 are the only mainstream compilers that come with a TR1 tuple 3980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by 3990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// defining __GNUC__ and friends, but cannot compile GCC's tuple 4000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB 4010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Feature Pack download, which we cannot assume the user has. 4020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ 4030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson || _MSC_VER >= 1600 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_USE_OWN_TR1_TUPLE 0 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_USE_OWN_TR1_TUPLE 1 4070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_USE_OWN_TR1_TUPLE 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// To avoid conditional compilation everywhere, we make it 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// gtest-port.h's responsibility to #include the header implementing 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// tr1/tuple. 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_TR1_TUPLE 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_USE_OWN_TR1_TUPLE 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/internal/gtest-tuple.h> 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif GTEST_OS_SYMBIAN 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// use STLport's tuple implementation, which unfortunately doesn't 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// work as the copy of STLport distributed with Symbian is incomplete. 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// use its own tuple implementation. 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef BOOST_HAS_TR1_TUPLE 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef BOOST_HAS_TR1_TUPLE 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // BOOST_HAS_TR1_TUPLE 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This prevents <boost/tr1/detail/config.hpp>, which defines 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <tuple> 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// not conform to the TR1 spec, which requires the header to be <tuple>. 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// which is #included by <tr1/tuple>, to not compile when RTTI is 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// disabled. _TR1_FUNCTIONAL is the header guard for 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// <tr1/functional>. Hence the following #define is a hack to prevent 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// <tr1/functional> from being included. 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define _TR1_FUNCTIONAL 1 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <tr1/tuple> 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef _TR1_FUNCTIONAL // Allows the user to #include 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // <tr1/functional> if he chooses to. 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 4490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <tr1/tuple> // NOLINT 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the compiler is not GCC 4.0+, we assume the user is using a 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// spec-conforming TR1 implementation. 4550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <tuple> // NOLINT 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_USE_OWN_TR1_TUPLE 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_TR1_TUPLE 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether clone(2) is supported. 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Usually it will only be available on Linux, excluding 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Linux on the Itanium architecture. 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Also see http://linux.die.net/man/2/clone. 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_CLONE 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us, so we need to figure it out. 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_LINUX && !defined(__ia64__) 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_CLONE 1 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_CLONE 0 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_LINUX && !defined(__ia64__) 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_CLONE 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 4750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Determines whether to support stream redirection. This is used to test 4760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// output correctness and to implement death tests. 4770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 4780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_STREAM_REDIRECTION_ 1 4790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 4800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether to support death tests. 4820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Google Test does not support death tests for VC 7.1 and earlier as 4830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// abort() in a VC 7.1 application compiled as GUI in debug config 4840ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// pops up a dialog window that cannot be suppressed programmatically. 4850ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 4860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 4870ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX) 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_DEATH_TEST 1 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <vector> // NOLINT 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 4920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// We don't support MSVC 7.1 with exceptions disabled now. Therefore 4930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// all the compilers we care about are adequate for supporting 4940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// value-parameterized tests. 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_PARAM_TEST 1 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether to support type-driven tests. 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 4990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, 5000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Sun Pro CC, and IBM Visual Age support. 5010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 5020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson defined(__IBMCPP__) 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_TYPED_TEST 1 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_TYPED_TEST_P 1 5050ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether to support Combine(). This only makes sense when 5080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// value-parameterized tests are enabled. The implementation doesn't 5090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// work on Sun Studio since it doesn't understand templated conversion 5100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// operators. 5110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_COMBINE 1 5130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determines whether the system compiler uses UTF-16 for encoding wide strings. 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_WIDE_STRING_USES_UTF16_ \ 5170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines some utility macros. 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The GNU compiler emits a warning if nested "if" statements are followed by 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// an "else" statement and braces are not used to explicitly disambiguate the 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "else" binding. This leads to problems with code like: 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if (gate) 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ASSERT_*(condition) << "Some message"; 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The "switch (0) case 0:" idiom is used to suppress this. 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __INTEL_COMPILER 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Use this annotation at the end of a struct/class definition to 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// prevent the compiler from optimizing away instances that are never 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// used. This is useful when all interesting logic happens inside the 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// c'tor and / or d'tor. Example: 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// struct Foo { 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Foo() { ... } 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } GTEST_ATTRIBUTE_UNUSED_; 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Also use it after a variable or parameter declaration to tell the 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// compiler the variable/parameter does not have to be used. 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(__GNUC__) && !defined(COMPILER_ICC) 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_ATTRIBUTE_UNUSED_ 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 5520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// A macro to disallow operator= 5530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// This should be used in the private: declarations for a class. 5540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DISALLOW_ASSIGN_(type)\ 5550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void operator=(type const &) 5560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 5570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// A macro to disallow copy constructor and operator= 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This should be used in the private: declarations for a class. 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 5600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson type(type const &);\ 5610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_ASSIGN_(type) 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tell the compiler to warn about unused return values for functions declared 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// with this macro. The macro should be used on function declarations 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// following the argument list: 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_MUST_USE_RESULT_ 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Determine whether the compiler supports Microsoft's Structured Exception 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Handling. This is supported by several Windows compilers but generally 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// does not exist on any other system. 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GTEST_HAS_SEH 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The user didn't tell us, so we need to figure it out. 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(_MSC_VER) || defined(__BORLANDC__) 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These two compilers are known to support SEH. 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_SEH 1 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Assume no SEH. 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_HAS_SEH 0 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_SEH 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 5900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#ifdef _MSC_VER 5910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 5920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_LINKED_AS_SHARED_LIBRARY 5930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_API_ __declspec(dllimport) 5940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif GTEST_CREATE_SHARED_LIBRARY 5950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_API_ __declspec(dllexport) 5960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 5970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 5980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // _MSC_VER 5990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 6000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#ifndef GTEST_API_ 6010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_API_ 6020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 6030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace testing { 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass Message; 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass String; 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef ::std::stringstream StrStream; 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 614d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// A helper for suppressing warnings on constant condition. It just 615d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// returns 'condition'. 6160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ bool IsTrue(bool condition); 617d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines scoped_ptr. 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This implementation of scoped_ptr is PARTIAL - it only contains 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// enough stuff to satisfy Google Test's need. 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass scoped_ptr { 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 6250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson typedef T element_type; 6260ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~scoped_ptr() { reset(); } 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T& operator*() const { return *ptr_; } 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* operator->() const { return ptr_; } 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* get() const { return ptr_; } 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* release() { 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* const ptr = ptr_; 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ptr_ = NULL; 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return ptr; 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void reset(T* p = NULL) { 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (p != ptr_) { 642d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete ptr_; 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ptr_ = p; 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* ptr_; 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines RE. 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 6560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Regular Expression syntax. 6580ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass GTEST_API_ RE { 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 6600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // A copy constructor is required by the Standard to initialize object 6610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // references from r-values. 6620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson RE(const RE& other) { Init(other.pattern()); } 6630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructs an RE from a string. 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_GLOBAL_STRING 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_STRING 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RE(const char* regex) { Init(regex); } // NOLINT 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~RE(); 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Returns the string representation of the regex. 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* pattern() const { return pattern_; } 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // FullMatch(str, re) returns true iff regular expression re matches 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the entire str. 679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // PartialMatch(str, re) returns true iff regular expression re 680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // matches a substring of str (including str itself). 681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TODO(wan@google.com): make FullMatch() and PartialMatch() work 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // when str contains NUL characters. 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool FullMatch(const ::std::string& str, const RE& re) { 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return FullMatch(str.c_str(), re); 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool PartialMatch(const ::std::string& str, const RE& re) { 688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return PartialMatch(str.c_str(), re); 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_GLOBAL_STRING 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool FullMatch(const ::string& str, const RE& re) { 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return FullMatch(str.c_str(), re); 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool PartialMatch(const ::string& str, const RE& re) { 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return PartialMatch(str.c_str(), re); 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_STRING 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool FullMatch(const char* str, const RE& re); 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool PartialMatch(const char* str, const RE& re); 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Init(const char* regex); 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We use a const char* instead of a string, as Google Test may be used 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // where string is not available. We also do not use Google Test's own 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // String type here, in order to simplify dependencies between the 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // files. 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* pattern_; 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool is_valid_; 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_USES_POSIX_RE 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville regex_t full_regex_; // For FullMatch(). 714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville regex_t partial_regex_; // For PartialMatch(). 715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else // GTEST_USES_SIMPLE_RE 716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* full_pattern_; // For FullMatch(); 717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 7190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_ASSIGN_(RE); 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines logging utilities: 723d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// GTEST_LOG_(severity) - logs messages at the specified severity level. The 724d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// message itself is streamed into the macro. 725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LogToStderr() - directs all log messages to stderr. 726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FlushInfoLog() - flushes informational log messages. 727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleenum GTestLogSeverity { 729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_INFO, 730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_WARNING, 731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_ERROR, 732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_FATAL 733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 735d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Formats log entry severity, provides a stream object for streaming the 736d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// log message, and terminates the message with a newline when going out of 737d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// scope. 7380ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass GTEST_API_ GTestLog { 739d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville public: 740d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville GTestLog(GTestLogSeverity severity, const char* file, int line); 741d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 742d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 743d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ~GTestLog(); 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 745d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ::std::ostream& GetStream() { return ::std::cerr; } 746d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 747d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville private: 748d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const GTestLogSeverity severity_; 749d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 750d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 751d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville}; 752d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 753d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GTEST_LOG_(severity) \ 754d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 755d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville __FILE__, __LINE__).GetStream() 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline void LogToStderr() {} 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline void FlushInfoLog() { fflush(NULL); } 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 7600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// INTERNAL IMPLEMENTATION - DO NOT USE. 7610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 7620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 7630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// is not satisfied. 7640ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Synopsys: 7650ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_CHECK_(boolean_condition); 7660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// or 7670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_CHECK_(boolean_condition) << "Additional message"; 7680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 7690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// This checks the condition and if the condition is not satisfied 7700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// it prints message about the condition violation, including the 7710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// condition itself, plus additional message streamed into it, if any, 7720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// and then it aborts the program. It aborts the program irrespective of 7730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// whether it is built in the debug mode or not. 7740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_CHECK_(condition) \ 7750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 7760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (::testing::internal::IsTrue(condition)) \ 7770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ; \ 7780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson else \ 7790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 7800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 7810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// An all-mode assert to verify that the given POSIX-style function 7820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// call returns 0 (indicating success). Known limitation: this 7830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// doesn't expand to a balanced 'if' statement, so enclose the macro 7840ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// in {} if you need to use it as the only statement in an 'if' 7850ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// branch. 7860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 7870ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (const int gtest_error = (posix_call)) \ 7880ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 7890ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson << gtest_error 7900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 7910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 7920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 7930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Downcasts the pointer of type Base to Derived. 7940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Derived must be a subclass of Base. The parameter MUST 7950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// point to a class of type Derived, not any subclass of it. 7960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// When RTTI is available, the function performs a runtime 7970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// check to enforce this. 7980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsontemplate <class Derived, class Base> 7990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonDerived* CheckedDowncastToActualType(Base* base) { 8000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_RTTI 8010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_(typeid(*base) == typeid(Derived)); 8020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return dynamic_cast<Derived*>(base); // NOLINT 8030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#else 8040ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return static_cast<Derived*>(base); // Poor man's downcast. 8050ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 8060ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson} 8070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_STREAM_REDIRECTION_ 8090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines the stderr capturer: 8110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// CaptureStdout - starts capturing stdout. 8120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GetCapturedStdout - stops capturing stdout and returns the captured string. 813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CaptureStderr - starts capturing stderr. 814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GetCapturedStderr - stops capturing stderr and returns the captured string. 8150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 8160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ void CaptureStdout(); 8170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ String GetCapturedStdout(); 8180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ void CaptureStderr(); 8190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ String GetCapturedStderr(); 8200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // GTEST_HAS_STREAM_REDIRECTION_ 822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A copy of all command line arguments. Set by InitGoogleTest(). 827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleextern ::std::vector<String> g_argvs; 828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GTEST_HAS_DEATH_TEST implies we have ::std::string. 830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst ::std::vector<String>& GetArgvs(); 831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Defines synchronization primitives. 835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 8360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_PTHREAD 8370ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8380ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Sleeps for (roughly) n milli-seconds. This function is only for 8390ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// testing Google Test's own constructs. Don't use it in user tests, 8400ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// either directly or indirectly. 8410ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsoninline void SleepMilliseconds(int n) { 8420ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const timespec time = { 8430ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 0, // 0 seconds. 8440ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson n * 1000L * 1000L, // And n ms. 8450ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson }; 8460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson nanosleep(&time, NULL); 8470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson} 8480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Allows a controller thread to pause execution of newly created 8500ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// threads until notified. Instances of this class must be created 8510ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// and destroyed in the controller thread. 8520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 8530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// This class is only for testing Google Test's own constructs. Do not 8540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// use it in user tests, either directly or indirectly. 8550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass Notification { 8560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 8570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson Notification() : notified_(false) {} 8580ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Notifies all threads created with this notification to start. Must 8600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // be called from the controller thread. 8610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void Notify() { notified_ = true; } 8620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Blocks until the controller thread notifies. Must be called from a test 8640ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // thread. 8650ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void WaitForNotification() { 8660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson while(!notified_) { 8670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson SleepMilliseconds(10); 8680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 8690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 8700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 8720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson volatile bool notified_; 8730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 8750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 8760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. 8780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Consequently, it cannot select a correct instantiation of ThreadWithParam 8790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// in order to call its Run(). Introducing ThreadWithParamBase as a 8800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// non-templated base class for ThreadWithParam allows us to bypass this 8810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// problem. 8820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass ThreadWithParamBase { 8830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 8840ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson virtual ~ThreadWithParamBase() {} 8850ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson virtual void Run() = 0; 8860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 8870ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8880ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// pthread_create() accepts a pointer to a function type with the C linkage. 8890ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// According to the Standard (7.5/1), function types with different linkages 8900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// are different even if they are otherwise identical. Some compilers (for 8910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// example, SunStudio) treat them as different types. Since class methods 8920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// cannot be defined with C-linkage we need to define a free C-function to 8930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// pass into pthread_create(). 8940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonextern "C" inline void* ThreadFuncWithCLinkage(void* thread) { 8950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson static_cast<ThreadWithParamBase*>(thread)->Run(); 8960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return NULL; 8970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson} 8980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 8990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Helper class for testing Google Test's multi-threading constructs. 9000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// To use it, write: 9010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// void ThreadFunc(int param) { /* Do things with param */ } 9030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Notification thread_can_start; 9040ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ... 9050ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// // The thread_can_start parameter is optional; you can supply NULL. 9060ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); 9070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// thread_can_start.Notify(); 9080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// These classes are only for testing Google Test's own constructs. Do 9100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// not use them in user tests, either directly or indirectly. 9110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsontemplate <typename T> 9120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass ThreadWithParam : public ThreadWithParamBase { 9130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 9140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson typedef void (*UserThreadFunc)(T); 9150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ThreadWithParam( 9170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson UserThreadFunc func, T param, Notification* thread_can_start) 9180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson : func_(func), 9190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson param_(param), 9200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson thread_can_start_(thread_can_start), 9210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson finished_(false) { 9220ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ThreadWithParamBase* const base = this; 9230ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // The thread can be created only after all fields except thread_ 9240ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // have been initialized. 9250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_( 9260ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); 9270ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9280ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ~ThreadWithParam() { Join(); } 9290ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9300ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void Join() { 9310ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (!finished_) { 9320ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); 9330ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson finished_ = true; 9340ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9350ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9370ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson virtual void Run() { 9380ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (thread_can_start_ != NULL) 9390ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson thread_can_start_->WaitForNotification(); 9400ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson func_(param_); 9410ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9420ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9430ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 9440ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const UserThreadFunc func_; // User-supplied thread function. 9450ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const T param_; // User-supplied parameter to the thread function. 9460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // When non-NULL, used to block execution until the controller thread 9470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // notifies. 9480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson Notification* const thread_can_start_; 9490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson bool finished_; // true iff we know that the thread function has finished. 9500ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_t thread_; // The native thread object. 9510ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 9530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 9540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is 9560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// true. 9570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#include <pthread.h> 9580ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// MutexBase and Mutex implement mutex on pthreads-based platforms. They 9600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// are used in conjunction with class MutexLock: 9610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Mutex mutex; 9630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ... 9640ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end 9650ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// // of the current scope. 9660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// MutexBase implements behavior for both statically and dynamically 9680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// allocated mutexes. Do not use MutexBase directly. Instead, write 9690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// the following to define a static mutex: 9700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); 9720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// You can forward declare a static mutex like this: 9740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); 9760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 9770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// To create a dynamic mutex, just define an object of type Mutex. 9780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass MutexBase { 9790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 9800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Acquires this mutex. 9810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void Lock() { 9820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); 9830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson owner_ = pthread_self(); 9840ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9850ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Releases this mutex. 9870ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void Unlock() { 9880ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // We don't protect writing to owner_ here, as it's the caller's 9890ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // responsibility to ensure that the current thread holds the 9900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // mutex when this is called. 9910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson owner_ = 0; 9920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); 9930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 9940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 9950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Does nothing if the current thread holds the mutex. Otherwise, crashes 9960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // with high probability. 9970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void AssertHeld() const { 9980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_(owner_ == pthread_self()) 9990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson << "The current thread is not holding the mutex @" << this; 10000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 10010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // A static mutex may be used before main() is entered. It may even 10030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // be used before the dynamic initialization stage. Therefore we 10040ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // must be able to initialize a static mutex object at link time. 10050ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // This means MutexBase has to be a POD and its member variables 10060ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // have to be public. 10070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 10080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_mutex_t mutex_; // The underlying pthread mutex. 10090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_t owner_; // The thread holding the mutex; 0 means no one holds it. 10100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 10110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Forward-declares a static mutex. 10130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 10140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson extern ::testing::internal::MutexBase mutex 10150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Defines and statically (i.e. at link time) initializes a static mutex. 10170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 10180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 } 10190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// The Mutex class can only be used for mutexes created at runtime. It 10210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// shares its API with MutexBase otherwise. 10220ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass Mutex : public MutexBase { 10230ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 10240ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson Mutex() { 10250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 10260ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson owner_ = 0; 10270ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 10280ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ~Mutex() { 10290ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); 10300ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 10310ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10320ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 10330ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 10340ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 10350ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// We cannot name this class MutexLock as the ctor declaration would 10370ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// conflict with a macro named MutexLock, which is defined on some 10380ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// platforms. Hence the typedef trick below. 10390ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass GTestMutexLock { 10400ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 10410ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson explicit GTestMutexLock(MutexBase* mutex) 10420ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson : mutex_(mutex) { mutex_->Lock(); } 10430ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10440ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ~GTestMutexLock() { mutex_->Unlock(); } 10450ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 10470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson MutexBase* const mutex_; 10480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 10500ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 10510ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsontypedef GTestMutexLock MutexLock; 10530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Helpers for ThreadLocal. 10550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// pthread_key_create() requires DeleteThreadLocalValue() to have 10570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// C-linkage. Therefore it cannot be templatized to access 10580ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ThreadLocal<T>. Hence the need for class 10590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ThreadLocalValueHolderBase. 10600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass ThreadLocalValueHolderBase { 10610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 10620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson virtual ~ThreadLocalValueHolderBase() {} 10630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 10640ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10650ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Called by pthread to delete thread-local data stored by 10660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// pthread_setspecific(). 10670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonextern "C" inline void DeleteThreadLocalValue(void* value_holder) { 10680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson delete static_cast<ThreadLocalValueHolderBase*>(value_holder); 10690ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson} 10700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 10710ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Implements thread-local storage on pthreads-based systems. 10720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// // Thread 1 10740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ThreadLocal<int> tl(100); // 100 is the default value for each thread. 10750ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// // Thread 2 10770ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// tl.set(150); // Changes the value for thread 2 only. 10780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// EXPECT_EQ(150, tl.get()); 10790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// // Thread 1 10810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. 10820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// tl.set(200); 10830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// EXPECT_EQ(200, tl.get()); 10840ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10850ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// The template type argument T must have a public copy constructor. 10860ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// In addition, the default ThreadLocal constructor requires T to have 10870ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// a public default constructor. 10880ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10890ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// An object managed for a thread by a ThreadLocal instance is deleted 10900ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// when the thread exits. Or, if the ThreadLocal instance dies in 10910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// that thread, when the ThreadLocal dies. It's the user's 10920ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// responsibility to ensure that all other threads using a ThreadLocal 10930ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// have exited when it dies, or the per-thread objects for those 10940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// threads will not be deleted. 10950ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// 10960ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Google Test only uses global ThreadLocal objects. That means they 10970ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// will die after main() has returned. Therefore, no per-thread 10980ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// object managed by Google Test will be leaked as long as all threads 10990ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// using Google Test have exited when main() returns. 11000ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsontemplate <typename T> 11010ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonclass ThreadLocal { 11020ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 11030ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ThreadLocal() : key_(CreateKey()), 11040ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson default_() {} 11050ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson explicit ThreadLocal(const T& value) : key_(CreateKey()), 11060ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson default_(value) {} 11070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ~ThreadLocal() { 11090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Destroys the managed object for the current thread, if any. 11100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DeleteThreadLocalValue(pthread_getspecific(key_)); 11110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Releases resources associated with the key. This will *not* 11130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // delete managed objects for other threads. 11140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); 11150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 11160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson T* pointer() { return GetOrCreateValue(); } 11180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const T* pointer() const { return GetOrCreateValue(); } 11190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const T& get() const { return *pointer(); } 11200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson void set(const T& value) { *pointer() = value; } 11210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11220ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 11230ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Holds a value of type T. 11240ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson class ValueHolder : public ThreadLocalValueHolderBase { 11250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson public: 11260ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson explicit ValueHolder(const T& value) : value_(value) {} 11270ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11280ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson T* pointer() { return &value_; } 11290ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11300ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson private: 11310ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson T value_; 11320ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 11330ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson }; 11340ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11350ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson static pthread_key_t CreateKey() { 11360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_key_t key; 11370ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // When a thread exits, DeleteThreadLocalValue() will be called on 11380ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // the object managed for that thread. 11390ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_( 11400ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson pthread_key_create(&key, &DeleteThreadLocalValue)); 11410ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return key; 11420ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 11430ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11440ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson T* GetOrCreateValue() const { 11450ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ThreadLocalValueHolderBase* const holder = 11460ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); 11470ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (holder != NULL) { 11480ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); 11490ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 11500ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11510ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ValueHolder* const new_holder = new ValueHolder(default_); 11520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ThreadLocalValueHolderBase* const holder_base = new_holder; 11530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); 11540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson return new_holder->pointer(); 11550ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson } 11560ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11570ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // A key pthreads uses for looking up per-thread values. 11580ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const pthread_key_t key_; 11590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson const T default_; // The default value for each thread. 11600ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11610ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 11620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson}; 11630ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11640ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_IS_THREADSAFE 1 11650ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#else // GTEST_HAS_PTHREAD 11670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 1168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A dummy implementation of synchronization primitives (mutex, lock, 1169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and thread-local variable). Necessary for compiling Google Test where 1170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// mutex is not supported - using Google Test in multiple threads is not 1171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// supported on such platforms. 1172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass Mutex { 1174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Mutex() {} 1176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void AssertHeld() const {} 1177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 11790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 11800ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson extern ::testing::internal::Mutex mutex 11810ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 11820ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 11830ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 1184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass GTestMutexLock { 1185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit GTestMutexLock(Mutex*) {} // NOLINT 1187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef GTestMutexLock MutexLock; 1190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass ThreadLocal { 1193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ThreadLocal() : value_() {} 1195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit ThreadLocal(const T& value) : value_(value) {} 1196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T* pointer() { return &value_; } 1197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T* pointer() const { return &value_; } 1198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T& get() const { return value_; } 1199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void set(const T& value) { value_ = value; } 1200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville T value_; 1202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The above synchronization primitives have dummy implementations. 1205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Therefore Google Test is not thread-safe. 1206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_IS_THREADSAFE 0 1207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 12080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // GTEST_HAS_PTHREAD 12090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 12100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// Returns the number of threads running in the process, or 0 to indicate that 12110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// we cannot detect it. 12120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ size_t GetThreadCount(); 1213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Passing non-POD classes through ellipsis (...) crashes the ARM 12150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// compiler and generates a warning in Sun Studio. The Nokia Symbian 12160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// and the IBM XL C/C++ compiler try to instantiate a copy constructor 12170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// for objects passed through ellipsis (...), failing for uncopyable 12180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// objects. We define this to ensure that only POD is passed through 12190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// ellipsis on these systems. 12200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 12210ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// We lose support for NULL detection where the compiler doesn't like 12220ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson// passing non-POD classes through ellipsis (...). 12230ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_ELLIPSIS_NEEDS_POD_ 1 12240ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#else 12250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_CAN_COMPARE_NULL 1 12260ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 1227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 1229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// const T& and const T* in a function template. These compilers 1230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// _can_ decide between class template specializations for T and T*, 1231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// so a tr1::type_traits-like is_pointer works. 12320ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 1233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_NEEDS_IS_POINTER_ 1 12340ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif 1235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <bool bool_value> 1237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct bool_constant { 1238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef bool_constant<bool_value> type; 1239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static const bool value = bool_value; 1240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <bool bool_value> const bool bool_constant<bool_value>::value; 1242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef bool_constant<false> false_type; 1244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef bool_constant<true> true_type; 1245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct is_pointer : public false_type {}; 1248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 1250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct is_pointer<T*> : public true_type {}; 1251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_PATH_SEP_ "\\" 12540ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_ALT_PATH_SEP_ 1 1255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The biggest signed integer type the compiler supports. 1256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef __int64 BiggestInt; 1257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_PATH_SEP_ "/" 12590ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_HAS_ALT_PATH_SEP_ 0 1260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef long long BiggestInt; // NOLINT 1261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The testing::internal::posix namespace holds wrappers for common 1264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// POSIX functions. These wrappers hide the differences between 1265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Windows/MSVC and POSIX systems. Since some compilers define these 1266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// standard functions as macros, the wrapper cannot have the same name 1267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as the wrapped function. 1268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace posix { 1270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Functions with a different name on Windows. 1272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef struct _stat StatStruct; 1276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __BORLANDC__ 1278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int IsATTY(int fd) { return isatty(fd); } 1279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int StrCaseCmp(const char* s1, const char* s2) { 1280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return stricmp(s1, s2); 1281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* StrDup(const char* src) { return strdup(src); } 1283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else // !__BORLANDC__ 1284d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if GTEST_OS_WINDOWS_MOBILE 1285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int IsATTY(int /* fd */) { return 0; } 1286d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#else 1287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int IsATTY(int fd) { return _isatty(fd); } 1288d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // GTEST_OS_WINDOWS_MOBILE 1289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int StrCaseCmp(const char* s1, const char* s2) { 1290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return _stricmp(s1, s2); 1291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* StrDup(const char* src) { return _strdup(src); } 1293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // __BORLANDC__ 1294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1295d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if GTEST_OS_WINDOWS_MOBILE 1296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 1297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 1298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// time and thus not defined there. 1299d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#else 1300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int FileNo(FILE* file) { return _fileno(file); } 1301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 1302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int RmDir(const char* dir) { return _rmdir(dir); } 1303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool IsDir(const StatStruct& st) { 1304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (_S_IFDIR & st.st_mode) != 0; 1305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1306d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // GTEST_OS_WINDOWS_MOBILE 1307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef struct stat StatStruct; 1311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int FileNo(FILE* file) { return fileno(file); } 1313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int IsATTY(int fd) { return isatty(fd); } 1314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 1315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int StrCaseCmp(const char* s1, const char* s2) { 1316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strcasecmp(s1, s2); 1317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* StrDup(const char* src) { return strdup(src); } 1319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int RmDir(const char* dir) { return rmdir(dir); } 1320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 1321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Functions deprecated by MSVC 8.0. 1325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 1327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Temporarily disable warning 4996 (deprecated function). 1328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(push) 1329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(disable:4996) 1330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline const char* StrNCpy(char* dest, const char* src, size_t n) { 1333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strncpy(dest, src, n); 1334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 1337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StrError() aren't needed on Windows CE at this time and thus not 1338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// defined there. 1339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1340d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if !GTEST_OS_WINDOWS_MOBILE 1341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int ChDir(const char* dir) { return chdir(dir); } 1342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline FILE* FOpen(const char* path, const char* mode) { 1344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return fopen(path, mode); 1345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1346d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if !GTEST_OS_WINDOWS_MOBILE 1347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 1348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return freopen(path, mode, stream); 1349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 1351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int FClose(FILE* fp) { return fclose(fp); } 1353d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if !GTEST_OS_WINDOWS_MOBILE 1354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int Read(int fd, void* buf, unsigned int count) { 1355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return static_cast<int>(read(fd, buf, count)); 1356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int Write(int fd, const void* buf, unsigned int count) { 1358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return static_cast<int>(write(fd, buf, count)); 1359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int Close(int fd) { return close(fd); } 1361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline const char* StrError(int errnum) { return strerror(errnum); } 1362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline const char* GetEnv(const char* name) { 1364d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if GTEST_OS_WINDOWS_MOBILE 1365d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // We are on Windows CE, which has no environment variables. 1366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return NULL; 13670ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 1368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Environment variables which we programmatically clear will be set to the 1369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // empty string rather than unset (NULL). Handle that case. 1370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* const env = getenv(name); 1371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (env != NULL && env[0] != '\0') ? env : NULL; 1372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return getenv(name); 1374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 1378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(pop) // Restores the warning state. 1379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 1380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1381d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if GTEST_OS_WINDOWS_MOBILE 1382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Windows CE has no C library. The abort() function is used in 1383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// several places in Google Test. This implementation provides a reasonable 1384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// imitation of standard behaviour. 1385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid Abort(); 1386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline void Abort() { abort(); } 1388d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // GTEST_OS_WINDOWS_MOBILE 1389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace posix 1391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The maximum number a BiggestInt can represent. This definition 1393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// works no matter BiggestInt is represented in one's complement or 1394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// two's complement. 1395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We cannot rely on numeric_limits in STL, as __int64 and long long 1397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// are not part of standard C++ and numeric_limits doesn't need to be 1398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// defined for them. 1399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst BiggestInt kMaxBiggestInt = 1400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 1401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This template class serves as a compile-time function from size to 1403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// type. It maps a size in bytes to a primitive type with that 1404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// size. e.g. 1405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TypeWithSize<4>::UInt 1407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is typedef-ed to be unsigned int (unsigned integer made up of 4 1409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// bytes). 1410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Such functionality should belong to STL, but I cannot find it 1412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// there. 1413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Google Test uses this class in the implementation of floating-point 1415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// comparison. 1416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For now it only handles UInt (unsigned int) as that's all Google Test 1418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// needs. Other types can be easily added in the future if need 1419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// arises. 1420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <size_t size> 1421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TypeWithSize { 1422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This prevents the user from using TypeWithSize<N> with incorrect 1424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // values of N. 1425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void UInt; 1426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The specialization for size 4. 1429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <> 1430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TypeWithSize<4> { 1431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // unsigned int has size 4 in both gcc and MSVC. 1433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // 1434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // As base/basictypes.h doesn't compile on Windows, we cannot use 1435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // uint32, uint64, and etc here. 1436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef int Int; 1437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef unsigned int UInt; 1438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The specialization for size 8. 1441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <> 1442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TypeWithSize<8> { 1443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef __int64 Int; 1446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef unsigned __int64 UInt; 1447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef long long Int; // NOLINT 1449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef unsigned long long UInt; // NOLINT 1450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Integer types of known sizes. 1454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef TypeWithSize<4>::Int Int32; 1455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef TypeWithSize<4>::UInt UInt32; 1456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef TypeWithSize<8>::Int Int64; 1457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef TypeWithSize<8>::UInt UInt64; 1458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 1459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Utilities for command line flags and environment variables. 1461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macro for referencing flags. 1463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_FLAG(name) FLAGS_gtest_##name 1464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for declaring flags. 14660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 1467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DECLARE_int32_(name) \ 14680ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 1469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DECLARE_string_(name) \ 14700ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name) 1471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Macros for defining flags. 1473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DEFINE_bool_(name, default_val, doc) \ 14740ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_API_ bool GTEST_FLAG(name) = (default_val) 1475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DEFINE_int32_(name, default_val, doc) \ 14760ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 1477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_DEFINE_string_(name, default_val, doc) \ 14780ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val) 1479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parses 'str' for a 32-bit signed integer. If successful, writes the result 1481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to *value and returns true; otherwise leaves *value unchanged and returns 1482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// false. 1483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TODO(chandlerc): Find a better way to refactor flag and environment parsing 1484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 1485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// function. 1486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool ParseInt32(const Message& src_text, const char* str, Int32* value); 1487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Parses a bool/Int32/string from the environment variable 1489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// corresponding to the given Google Test flag. 1490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool BoolFromGTestEnv(const char* flag, bool default_val); 14910ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff DavidsonGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 1492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst char* StringFromGTestEnv(const char* flag, const char* default_val); 1493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace testing 1496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1498