13d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Copyright 2005, Google Inc. 23d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// All rights reserved. 33d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 43d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Redistribution and use in source and binary forms, with or without 53d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// modification, are permitted provided that the following conditions are 63d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// met: 73d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 83d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// * Redistributions of source code must retain the above copyright 93d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// notice, this list of conditions and the following disclaimer. 103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// * Redistributions in binary form must reproduce the above 113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// copyright notice, this list of conditions and the following disclaimer 123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// in the documentation and/or other materials provided with the 133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// distribution. 143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// * Neither the name of Google Inc. nor the names of its 153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// contributors may be used to endorse or promote products derived from 163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// this software without specific prior written permission. 173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Authors: wan@google.com (Zhanyong Wan) 313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Low-level types and utilities for porting Google Test to various 333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// platforms. They are subject to change without notice. DO NOT USE 343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// THEM IN USER CODE. 353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user can define the following macros in the build script to 403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// control Google Test's behavior. If the user doesn't define a macro 413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// in this list, Google Test will define it. 423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is/isn't available. 453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions 463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// are enabled. 473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is/isn't available (some systems define 493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ::string, which is different to std::string). 503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is/isn't available (some systems define 523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ::wstring, which is different to std::wstring). 533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular 543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// expressions are/aren't available. 553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is/isn't available. 573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// enabled. 593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// std::wstring does/doesn't work (Google Test can 613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// be used where std::wstring is unavailable). 623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is/isn't available. 643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// compiler supports Microsoft's "Structured 663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Exception Handling". 673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_STREAM_REDIRECTION 683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - Define it to 1/0 to indicate whether the 693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// platform supports I/O stream redirection using 703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// dup() and dup2(). 713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Test's own tr1 tuple implementation should be 733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// used. Unused when the user sets 743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_TR1_TUPLE to 0. 753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_LINKED_AS_SHARED_LIBRARY 763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - Define to 1 when compiling tests that use 773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Google Test as a shared library (known as 783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// DLL on Windows). 793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_CREATE_SHARED_LIBRARY 803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - Define to 1 when compiling Google Test itself 813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// as a shared library. 823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This header defines the following utilities: 843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macros indicating the current platform (defined to 1 if compiled on 863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the given platform; otherwise undefined): 873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_AIX - IBM AIX 883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_CYGWIN - Cygwin 893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_HPUX - HP-UX 903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_LINUX - Linux 913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_LINUX_ANDROID - Google Android 923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_MAC - Mac OS X 933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_NACL - Google Native Client (NaCl) 943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_SOLARIS - Sun Solaris 953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_SYMBIAN - Symbian 963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_WINDOWS_MINGW - MinGW 993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 1003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_OS_ZOS - z/OS 1013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 1033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// most stable support. Since core members of the Google Test project 1043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// don't have access to other platforms, support for them may be less 1053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// stable. If you notice any problems on your platform, please notify 1063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// googletestframework@googlegroups.com (patches for fixing them are 1073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// even more welcome!). 1083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Note that it is possible that none of the GTEST_OS_* macros are defined. 1103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macros indicating available Google Test features (defined to 1 if 1123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the corresponding feature is supported; otherwise undefined): 1133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 1143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// tests) 1153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_DEATH_TEST - death tests 1163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_PARAM_TEST - value-parameterized tests 1173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_TYPED_TEST - typed tests 1183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 1193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with 1203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_POSIX_RE (see above) which users can 1213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// define themselves. 1223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_USES_SIMPLE_RE - our own simple regex is used; 1233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the above two are mutually exclusive. 1243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). 1253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macros for basic C++ coding: 1273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 1283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 1293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// variable don't have to be used. 1303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DISALLOW_ASSIGN_ - disables operator=. 1313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 1323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 1333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Synchronization: 1353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Mutex, MutexLock, ThreadLocal, GetThreadCount() 1363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - synchronization primitives. 1373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 1383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// synchronization primitives have real implementations 1393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// and Google Test is thread-safe; or 0 otherwise. 1403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Template meta programming: 1423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 1433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// IteratorTraits - partial implementation of std::iterator_traits, which 1443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is not available in libCstd when compiled with Sun C++. 1453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Smart pointers: 1473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// scoped_ptr - as in TR2. 1483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Regular expressions: 1503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// RE - a simple regular expression class using the POSIX 1513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Extended Regular Expression syntax on UNIX-like 1523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// platforms, or a reduced regular exception syntax on 1533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// other platforms, including Windows. 1543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Logging: 1563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_LOG_() - logs messages at the specified severity level. 1573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// LogToStderr() - directs all log messages to stderr. 1583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// FlushInfoLog() - flushes informational log messages. 1593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Stdout and stderr capturing: 1613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// CaptureStdout() - starts capturing stdout. 1623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetCapturedStdout() - stops capturing stdout and returns the captured 1633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// string. 1643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// CaptureStderr() - starts capturing stderr. 1653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetCapturedStderr() - stops capturing stderr and returns the captured 1663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// string. 1673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Integer types: 1693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// TypeWithSize - maps an integer to a int type. 1703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Int32, UInt32, Int64, UInt64, TimeInMillis 1713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - integers of known sizes. 1723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// BiggestInt - the biggest signed integer type. 1733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Command-line utilities: 1753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_FLAG() - references a flag. 1763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DECLARE_*() - declares a flag. 1773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DEFINE_*() - defines a flag. 1783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetArgvs() - returns the command line as a vector of strings. 1793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 1803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Environment variable utilities: 1813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetEnv() - gets the value of an environment variable. 1823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// BoolFromGTestEnv() - parses a bool environment variable. 1833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Int32FromGTestEnv() - parses an Int32 environment variable. 1843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// StringFromGTestEnv() - parses a string environment variable. 1853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 1863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <ctype.h> // for isspace, etc 1873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <stddef.h> // for ptrdiff_t 1883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <stdlib.h> 1893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <stdio.h> 1903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <string.h> 1913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef _WIN32_WCE 1923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <sys/types.h> 1933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <sys/stat.h> 1943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // !_WIN32_WCE 1953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 1963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <iostream> // NOLINT 1973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <sstream> // NOLINT 1983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#include <string> // NOLINT 1993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 2013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_FLAG_PREFIX_ "gtest_" 2023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_FLAG_PREFIX_DASH_ "gtest-" 2033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 2043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_NAME_ "Google Test" 2053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 2063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines the version of gcc that is used to compile this. 2083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef __GNUC__ 2093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 40302 means version 4.3.2. 2103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_GCC_VER_ \ 2113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 2123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // __GNUC__ 2133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines the platform on which Google Test is compiled. 2153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef __CYGWIN__ 2163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_CYGWIN 1 2173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined __SYMBIAN32__ 2183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_SYMBIAN 1 2193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined _WIN32 2203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_WINDOWS 1 2213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef _WIN32_WCE 2223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_WINDOWS_MOBILE 1 2233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__MINGW__) || defined(__MINGW32__) 2243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_WINDOWS_MINGW 1 2253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 2263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_WINDOWS_DESKTOP 1 2273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // _WIN32_WCE 2283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined __APPLE__ 2293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_MAC 1 2303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined __linux__ 2313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_LINUX 1 2323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef ANDROID 2333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_LINUX_ANDROID 1 2343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // ANDROID 2353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined __MVS__ 2363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_ZOS 1 2373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined(__sun) && defined(__SVR4) 2383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_SOLARIS 1 2393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined(_AIX) 2403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_AIX 1 2413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined(__hpux) 2423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_HPUX 1 2433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined __native_client__ 2443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_OS_NACL 1 2453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // __CYGWIN__ 2463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Brings in definitions for functions used in the testing::internal::posix 2483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// namespace (read, write, close, chdir, isatty, stat). We do not currently 2493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// use them on Windows Mobile. 2503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if !GTEST_OS_WINDOWS 2513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This assumes that non-Windows OSes provide unistd.h. For OSes where this 2523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is not the case, we need to include headers that provide the functions 2533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// mentioned above. 2543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <unistd.h> 2553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if !GTEST_OS_NACL 2563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// TODO(vladl@google.com): Remove this condition when Native Client SDK adds 2573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// strings.h (tracked in 2583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// http://code.google.com/p/nativeclient/issues/detail?id=1175). 2593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <strings.h> // Native Client doesn't provide strings.h. 2603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 2613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif !GTEST_OS_WINDOWS_MOBILE 2623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <direct.h> 2633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <io.h> 2643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 2653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines this to true iff Google Test can use POSIX regular expressions. 2673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_POSIX_RE 2683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) 2693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 2703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_POSIX_RE 2723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// On some platforms, <regex.h> needs someone to define size_t, and 2743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// won't compile otherwise. We can #include it here as we already 2753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// included <stdlib.h>, which is guaranteed to define size_t through 2763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// <stddef.h>. 2773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <regex.h> // NOLINT 2783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_USES_POSIX_RE 1 2803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif GTEST_OS_WINDOWS 2823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// <regex.h> is not available on Windows. Use our own simple regex 2843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// implementation instead. 2853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_USES_SIMPLE_RE 1 2863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 2883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// <regex.h> may not be available on this platform. Use our own 2903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// simple regex implementation instead. 2913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_USES_SIMPLE_RE 1 2923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_POSIX_RE 2943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 2953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_EXCEPTIONS 2963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us whether exceptions are enabled, so we need 2973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to figure it out. 2983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if defined(_MSC_VER) || defined(__BORLANDC__) 2993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 3003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// macro to enable exceptions, so we'll do the same. 3013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Assumes that exceptions are enabled by default. 3023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifndef _HAS_EXCEPTIONS 3033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define _HAS_EXCEPTIONS 1 3043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // _HAS_EXCEPTIONS 3053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 3063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__GNUC__) && __EXCEPTIONS 3073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 3083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS 1 3093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__SUNPRO_CC) 3103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Sun Pro CC supports exceptions. However, there is no compile-time way of 3113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// detecting whether they are enabled or not. Therefore, we assume that 3123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// they are enabled unless the user tells us otherwise. 3133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS 1 3143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__IBMCPP__) && __EXCEPTIONS 3153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. 3163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS 1 3173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__HP_aCC) 3183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Exception handling is in effect by default in HP aCC compiler. It has to 3193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// be turned of by +noeh compiler option if desired. 3203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS 1 3213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 3223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// For other compilers, we assume exceptions are disabled to be 3233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// conservative. 3243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_EXCEPTIONS 0 3253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // defined(_MSC_VER) || defined(__BORLANDC__) 3263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_EXCEPTIONS 3273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if !defined(GTEST_HAS_STD_STRING) 3293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Even though we don't use this macro any longer, we keep it in case 3303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// some clients still depend on it. 3313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_STD_STRING 1 3323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif !GTEST_HAS_STD_STRING 3333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user told us that ::std::string isn't available. 3343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# error "Google Test cannot be used where ::std::string isn't available." 3353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // !defined(GTEST_HAS_STD_STRING) 3363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_GLOBAL_STRING 3383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us whether ::string is available, so we need 3393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to figure it out. 3403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_GLOBAL_STRING 0 3423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_STRING 3443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_STD_WSTRING 3463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us whether ::std::wstring is available, so we need 3473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to figure it out. 3483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 3493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is available. 3503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Cygwin 1.7 and below doesn't support ::std::wstring. 3523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Solaris' libc++ doesn't support it either. Android has 3533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// no support for it at least as recent as Froyo (2.2). 3543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_STD_WSTRING \ 3553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 3563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_STD_WSTRING 3583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_GLOBAL_WSTRING 3603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us whether ::wstring is available, so we need 3613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to figure it out. 3623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_GLOBAL_WSTRING \ 3633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 3643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_WSTRING 3653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether RTTI is available. 3673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_RTTI 3683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us whether RTTI is enabled, so we need to 3693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// figure it out. 3703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef _MSC_VER 3723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 3743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 1 3753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 3763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 0 3773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 3783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 3803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 3813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef __GXX_RTTI 3833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 1 3843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 3853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 0 3863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // __GXX_RTTI 3873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if 3893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// both the typeid and dynamic_cast features are present. 3903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 3913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef __RTTI_ALL__ 3933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 1 3943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 3953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 0 3963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 3973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 3983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 3993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// For all other compilers, we assume RTTI is enabled. 4013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_RTTI 1 4023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // _MSC_VER 4043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_RTTI 4063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// It's this header's responsibility to #include <typeinfo> when RTTI 4083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is enabled. 4093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_RTTI 4103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <typeinfo> 4113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 4123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether Google Test can use the pthreads library. 4143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_PTHREAD 4153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us explicitly, so we assume pthreads support is 4163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// available on Linux and Mac. 4173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 4183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 4193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to your compiler flags. 4203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX) 4213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_PTHREAD 4223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_PTHREAD 4243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is 4253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// true. 4263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <pthread.h> // NOLINT 4273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// For timespec and nanosleep, used below. 4293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <time.h> // NOLINT 4303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 4313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether Google Test can use tr1/tuple. You can define 4333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// this macro to 0 to prevent Google Test from using tuple (any 4343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// feature depending on tuple with be disabled in this mode). 4353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_TR1_TUPLE 4363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us not to do it, so we assume it's OK. 4373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_TR1_TUPLE 1 4383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_TR1_TUPLE 4393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether Google Test's own tr1 tuple implementation 4413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// should be used. 4423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_USE_OWN_TR1_TUPLE 4433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us, so we need to figure it out. 4443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// We use our own TR1 tuple if we aren't sure the user has an 4463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// implementation of it already. At this time, GCC 4.0.0+ and MSVC 4473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 2010 are the only mainstream compilers that come with a TR1 tuple 4483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by 4493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// defining __GNUC__ and friends, but cannot compile GCC's tuple 4503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB 4513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Feature Pack download, which we cannot assume the user has. 4523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ 4533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick || _MSC_VER >= 1600 4543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_USE_OWN_TR1_TUPLE 0 4553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 4563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_USE_OWN_TR1_TUPLE 1 4573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 4583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_USE_OWN_TR1_TUPLE 4603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// To avoid conditional compilation everywhere, we make it 4623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// gtest-port.h's responsibility to #include the header implementing 4633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// tr1/tuple. 4643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_TR1_TUPLE 4653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_USE_OWN_TR1_TUPLE 4673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include "gtest/internal/gtest-tuple.h" 4683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif GTEST_OS_SYMBIAN 4693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 4713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// use STLport's tuple implementation, which unfortunately doesn't 4723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// work as the copy of STLport distributed with Symbian is incomplete. 4733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 4743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// use its own tuple implementation. 4753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef BOOST_HAS_TR1_TUPLE 4763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# undef BOOST_HAS_TR1_TUPLE 4773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // BOOST_HAS_TR1_TUPLE 4783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This prevents <boost/tr1/detail/config.hpp>, which defines 4803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 4813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 4823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <tuple> 4833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 4853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 4863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// not conform to the TR1 spec, which requires the header to be <tuple>. 4873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 4883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 4893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 4903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// which is #included by <tr1/tuple>, to not compile when RTTI is 4913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// disabled. _TR1_FUNCTIONAL is the header guard for 4923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// <tr1/functional>. Hence the following #define is a hack to prevent 4933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// <tr1/functional> from being included. 4943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define _TR1_FUNCTIONAL 1 4953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <tr1/tuple> 4963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# undef _TR1_FUNCTIONAL // Allows the user to #include 4973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // <tr1/functional> if he chooses to. 4983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 4993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <tr1/tuple> // NOLINT 5003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 5013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 5033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// If the compiler is not GCC 4.0+, we assume the user is using a 5043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// spec-conforming TR1 implementation. 5053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <tuple> // NOLINT 5063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // GTEST_USE_OWN_TR1_TUPLE 5073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_TR1_TUPLE 5093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether clone(2) is supported. 5113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Usually it will only be available on Linux, excluding 5123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Linux on the Itanium architecture. 5133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Also see http://linux.die.net/man/2/clone. 5143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_CLONE 5153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us, so we need to figure it out. 5163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_OS_LINUX && !defined(__ia64__) 5183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_CLONE 1 5193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 5203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_CLONE 0 5213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // GTEST_OS_LINUX && !defined(__ia64__) 5223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_CLONE 5243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether to support stream redirection. This is used to test 5263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// output correctness and to implement death tests. 5273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_STREAM_REDIRECTION 5283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// By default, we assume that stream redirection is supported on all 5293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// platforms except known mobile ones. 5303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN 5313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_STREAM_REDIRECTION 0 5323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 5333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_STREAM_REDIRECTION 1 5343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 5353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_STREAM_REDIRECTION 5363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether to support death tests. 5383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Google Test does not support death tests for VC 7.1 and earlier as 5393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// abort() in a VC 7.1 application compiled as GUI in debug config 5403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// pops up a dialog window that cannot be suppressed programmatically. 5413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 5423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 5433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX) 5443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_DEATH_TEST 1 5453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# include <vector> // NOLINT 5463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 5473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// We don't support MSVC 7.1 with exceptions disabled now. Therefore 5493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// all the compilers we care about are adequate for supporting 5503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// value-parameterized tests. 5513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_HAS_PARAM_TEST 1 5523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether to support type-driven tests. 5543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, 5563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Sun Pro CC, IBM Visual Age, and HP aCC support. 5573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 5583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick defined(__IBMCPP__) || defined(__HP_aCC) 5593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_TYPED_TEST 1 5603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_TYPED_TEST_P 1 5613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 5623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether to support Combine(). This only makes sense when 5643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// value-parameterized tests are enabled. The implementation doesn't 5653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// work on Sun Studio since it doesn't understand templated conversion 5663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// operators. 5673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 5683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_COMBINE 1 5693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 5703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether the system compiler uses UTF-16 for encoding wide strings. 5723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_WIDE_STRING_USES_UTF16_ \ 5733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 5743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determines whether test results can be streamed to a socket. 5763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_LINUX 5773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_CAN_STREAM_RESULTS_ 1 5783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 5793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines some utility macros. 5813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The GNU compiler emits a warning if nested "if" statements are followed by 5833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// an "else" statement and braces are not used to explicitly disambiguate the 5843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// "else" binding. This leads to problems with code like: 5853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 5863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// if (gate) 5873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ASSERT_*(condition) << "Some message"; 5883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 5893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The "switch (0) case 0:" idiom is used to suppress this. 5903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef __INTEL_COMPILER 5913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 5923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 5933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT 5943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 5953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 5963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Use this annotation at the end of a struct/class definition to 5973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// prevent the compiler from optimizing away instances that are never 5983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// used. This is useful when all interesting logic happens inside the 5993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// c'tor and / or d'tor. Example: 6003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// struct Foo { 6023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Foo() { ... } 6033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// } GTEST_ATTRIBUTE_UNUSED_; 6043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Also use it after a variable or parameter declaration to tell the 6063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// compiler the variable/parameter does not have to be used. 6073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if defined(__GNUC__) && !defined(COMPILER_ICC) 6083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 6093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 6103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_ATTRIBUTE_UNUSED_ 6113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 6123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A macro to disallow operator= 6143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This should be used in the private: declarations for a class. 6153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DISALLOW_ASSIGN_(type)\ 6163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void operator=(type const &) 6173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A macro to disallow copy constructor and operator= 6193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This should be used in the private: declarations for a class. 6203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 6213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick type(type const &);\ 6223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_ASSIGN_(type) 6233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Tell the compiler to warn about unused return values for functions declared 6253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// with this macro. The macro should be used on function declarations 6263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// following the argument list: 6273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 6293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 6303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 6313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 6323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_MUST_USE_RESULT_ 6333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 6343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Determine whether the compiler supports Microsoft's Structured Exception 6363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Handling. This is supported by several Windows compilers but generally 6373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// does not exist on any other system. 6383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_HAS_SEH 6393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The user didn't tell us, so we need to figure it out. 6403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if defined(_MSC_VER) || defined(__BORLANDC__) 6423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// These two compilers are known to support SEH. 6433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_SEH 1 6443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 6453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Assume no SEH. 6463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_SEH 0 6473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 6483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_SEH 6503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef _MSC_VER 6523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_LINKED_AS_SHARED_LIBRARY 6543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_API_ __declspec(dllimport) 6553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# elif GTEST_CREATE_SHARED_LIBRARY 6563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_API_ __declspec(dllexport) 6573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif 6583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // _MSC_VER 6603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifndef GTEST_API_ 6623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_API_ 6633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 6643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef __GNUC__ 6663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Ask the compiler to never inline a given function. 6673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_NO_INLINE_ __attribute__((noinline)) 6683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 6693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_NO_INLINE_ 6703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 6713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicknamespace testing { 6733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass Message; 6753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicknamespace internal { 6773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass String; 6793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time 6813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// expression is true. For example, you could use it to verify the 6823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// size of a static array: 6833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, 6853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// content_type_names_incorrect_size); 6863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// or to make sure a struct is smaller than a certain size: 6883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); 6903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 6913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The second argument to the macro is the name of the variable. If 6923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the expression is false, most compilers will issue a warning/error 6933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// containing the name of the variable. 6943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <bool> 6963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct CompileAssert { 6973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 6983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 6993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_COMPILE_ASSERT_(expr, msg) \ 7003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef ::testing::internal::CompileAssert<(bool(expr))> \ 7013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick msg[bool(expr) ? 1 : -1] 7023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Implementation details of GTEST_COMPILE_ASSERT_: 7043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 7063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// elements (and thus is invalid) when the expression is false. 7073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - The simpler definition 7093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] 7113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// does not work, as gcc supports variable-length arrays whose sizes 7133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// are determined at run-time (this is gcc's extension and not part 7143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// of the C++ standard). As a result, gcc fails to reject the 7153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// following code with the simple definition: 7163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// int foo; 7183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is 7193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // not a compile-time constant. 7203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - By using the type CompileAssert<(bool(expr))>, we ensures that 7223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// expr is a compile-time constant. (Template arguments must be 7233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// determined at compile-time.) 7243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - The outter parentheses in CompileAssert<(bool(expr))> are necessary 7263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written 7273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// CompileAssert<bool(expr)> 7293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// instead, these compilers will refuse to compile 7313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_COMPILE_ASSERT_(5 > 0, some_message); 7333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// (They seem to think the ">" in "5 > 0" marks the end of the 7353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// template argument list.) 7363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// - The array size is (bool(expr) ? 1 : -1), instead of simply 7383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ((expr) ? 1 : -1). 7403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This is to avoid running into a bug in MS VC 7.1, which 7423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. 7433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. 7453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 7463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This template is declared, but intentionally undefined. 7473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T1, typename T2> 7483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct StaticAssertTypeEqHelper; 7493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 7513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct StaticAssertTypeEqHelper<T, T> {}; 7523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_GLOBAL_STRING 7543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef ::string string; 7553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 7563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef ::std::string string; 7573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_STRING 7583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_GLOBAL_WSTRING 7603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef ::wstring wstring; 7613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif GTEST_HAS_STD_WSTRING 7623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef ::std::wstring wstring; 7633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_WSTRING 7643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A helper for suppressing warnings on constant condition. It just 7663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// returns 'condition'. 7673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ bool IsTrue(bool condition); 7683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines scoped_ptr. 7703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This implementation of scoped_ptr is PARTIAL - it only contains 7723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// enough stuff to satisfy Google Test's need. 7733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 7743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass scoped_ptr { 7753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 7763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef T element_type; 7773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 7793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~scoped_ptr() { reset(); } 7803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T& operator*() const { return *ptr_; } 7823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* operator->() const { return ptr_; } 7833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* get() const { return ptr_; } 7843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* release() { 7863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* const ptr = ptr_; 7873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ptr_ = NULL; 7883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return ptr; 7893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 7903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 7913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void reset(T* p = NULL) { 7923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (p != ptr_) { 7933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 7943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick delete ptr_; 7953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 7963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ptr_ = p; 7973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 7983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 7993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 8003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* ptr_; 8013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 8033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 8043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines RE. 8063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended 8083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Regular Expression syntax. 8093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass GTEST_API_ RE { 8103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 8113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // A copy constructor is required by the Standard to initialize object 8123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // references from r-values. 8133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick RE(const RE& other) { Init(other.pattern()); } 8143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Constructs an RE from a string. 8163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 8173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_GLOBAL_STRING 8193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 8213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_STRING 8233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick RE(const char* regex) { Init(regex); } // NOLINT 8253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~RE(); 8263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Returns the string representation of the regex. 8283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const char* pattern() const { return pattern_; } 8293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // FullMatch(str, re) returns true iff regular expression re matches 8313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // the entire str. 8323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // PartialMatch(str, re) returns true iff regular expression re 8333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // matches a substring of str (including str itself). 8343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // 8353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // TODO(wan@google.com): make FullMatch() and PartialMatch() work 8363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // when str contains NUL characters. 8373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool FullMatch(const ::std::string& str, const RE& re) { 8383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return FullMatch(str.c_str(), re); 8393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 8403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool PartialMatch(const ::std::string& str, const RE& re) { 8413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return PartialMatch(str.c_str(), re); 8423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 8433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_GLOBAL_STRING 8453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool FullMatch(const ::string& str, const RE& re) { 8473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return FullMatch(str.c_str(), re); 8483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 8493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool PartialMatch(const ::string& str, const RE& re) { 8503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return PartialMatch(str.c_str(), re); 8513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 8523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_GLOBAL_STRING 8543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool FullMatch(const char* str, const RE& re); 8563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static bool PartialMatch(const char* str, const RE& re); 8573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 8593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void Init(const char* regex); 8603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // We use a const char* instead of a string, as Google Test may be used 8623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // where string is not available. We also do not use Google Test's own 8633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // String type here, in order to simplify dependencies between the 8643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // files. 8653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const char* pattern_; 8663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick bool is_valid_; 8673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_USES_POSIX_RE 8693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick regex_t full_regex_; // For FullMatch(). 8713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick regex_t partial_regex_; // For PartialMatch(). 8723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else // GTEST_USES_SIMPLE_RE 8743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const char* full_pattern_; // For FullMatch(); 8763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 8783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_ASSIGN_(RE); 8803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 8813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Formats a source file path and a line number as they would appear 8833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// in an error message from the compiler used to compile this code. 8843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ ::std::string FormatFileLocation(const char* file, int line); 8853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Formats a file location for compiler-independent XML output. 8873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Although this function is not platform dependent, we put it next to 8883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// FormatFileLocation in order to contrast the two functions. 8893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, 8903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick int line); 8913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines logging utilities: 8933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_LOG_(severity) - logs messages at the specified severity level. The 8943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// message itself is streamed into the macro. 8953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// LogToStderr() - directs all log messages to stderr. 8963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// FlushInfoLog() - flushes informational log messages. 8973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 8983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickenum GTestLogSeverity { 8993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_INFO, 9003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_WARNING, 9013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_ERROR, 9023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_FATAL 9033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 9043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Formats log entry severity, provides a stream object for streaming the 9063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// log message, and terminates the message with a newline when going out of 9073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// scope. 9083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass GTEST_API_ GTestLog { 9093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 9103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTestLog(GTestLogSeverity severity, const char* file, int line); 9113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 9133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~GTestLog(); 9143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ::std::ostream& GetStream() { return ::std::cerr; } 9163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 9183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const GTestLogSeverity severity_; 9193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 9213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 9223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_LOG_(severity) \ 9243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 9253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick __FILE__, __LINE__).GetStream() 9263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline void LogToStderr() {} 9283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline void FlushInfoLog() { fflush(NULL); } 9293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// INTERNAL IMPLEMENTATION - DO NOT USE. 9313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 9333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is not satisfied. 9343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Synopsys: 9353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_CHECK_(boolean_condition); 9363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// or 9373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_CHECK_(boolean_condition) << "Additional message"; 9383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This checks the condition and if the condition is not satisfied 9403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// it prints message about the condition violation, including the 9413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// condition itself, plus additional message streamed into it, if any, 9423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// and then it aborts the program. It aborts the program irrespective of 9433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// whether it is built in the debug mode or not. 9443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_CHECK_(condition) \ 9453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 9463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (::testing::internal::IsTrue(condition)) \ 9473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ; \ 9483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick else \ 9493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 9503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// An all-mode assert to verify that the given POSIX-style function 9523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// call returns 0 (indicating success). Known limitation: this 9533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// doesn't expand to a balanced 'if' statement, so enclose the macro 9543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// in {} if you need to use it as the only statement in an 'if' 9553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// branch. 9563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 9573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (const int gtest_error = (posix_call)) \ 9583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 9593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick << gtest_error 9603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 9623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Use ImplicitCast_ as a safe version of static_cast for upcasting in 9643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a 9653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// const Foo*). When you use ImplicitCast_, the compiler checks that 9663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the cast is safe. Such explicit ImplicitCast_s are necessary in 9673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// surprisingly many situations where C++ demands an exact type match 9683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// instead of an argument type convertable to a target type. 9693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The syntax for using ImplicitCast_ is the same as for static_cast: 9713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ImplicitCast_<ToType>(expr) 9733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ImplicitCast_ would have been part of the C++ standard library, 9753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// but the proposal was submitted too late. It will probably make 9763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// its way into the language in the future. 9773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 9783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This relatively ugly name is intentional. It prevents clashes with 9793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// similar functions users may have (e.g., implicit_cast). The internal 9803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// namespace alone is not enough because the function can be found by ADL. 9813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate<typename To> 9823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline To ImplicitCast_(To x) { return x; } 9833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 9843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// When you upcast (that is, cast a pointer from type Foo to type 9853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts 9863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// always succeed. When you downcast (that is, cast a pointer from 9873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 9883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// how do you know the pointer is really of type SubclassOfFoo? It 9893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 9903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// when you downcast, you should use this macro. In debug mode, we 9913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// use dynamic_cast<> to double-check the downcast is legal (we die 9923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// if it's not). In normal mode, we do the efficient static_cast<> 9933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// instead. Thus, it's important to test in debug mode to make sure 9943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the cast is legal! 9953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This is the only place in the code we should use dynamic_cast<>. 9963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// In particular, you SHOULDN'T be using dynamic_cast<> in order to 9973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// do RTTI (eg code like this: 9983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); 9993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); 10003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// You should design the code some other way not to need this. 10013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 10023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This relatively ugly name is intentional. It prevents clashes with 10033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// similar functions users may have (e.g., down_cast). The internal 10043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// namespace alone is not enough because the function can be found by ADL. 10053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate<typename To, typename From> // use like this: DownCast_<T*>(foo); 10063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline To DownCast_(From* f) { // so we only accept pointers 10073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Ensures that To is a sub-type of From *. This test is here only 10083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // for compile-time type checking, and has no overhead in an 10093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // optimized build at run-time, as it will be optimized away 10103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // completely. 10113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (false) { 10123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const To to = NULL; 10133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ::testing::internal::ImplicitCast_<From*>(to); 10143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 10153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_RTTI 10173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // RTTI: debug mode only! 10183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL); 10193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 10203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<To>(f); 10213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 10223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Downcasts the pointer of type Base to Derived. 10243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Derived must be a subclass of Base. The parameter MUST 10253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// point to a class of type Derived, not any subclass of it. 10263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// When RTTI is available, the function performs a runtime 10273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// check to enforce this. 10283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <class Derived, class Base> 10293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickDerived* CheckedDowncastToActualType(Base* base) { 10303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_RTTI 10313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_(typeid(*base) == typeid(Derived)); 10323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return dynamic_cast<Derived*>(base); // NOLINT 10333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 10343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<Derived*>(base); // Poor man's downcast. 10353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 10363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 10373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_STREAM_REDIRECTION 10393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines the stderr capturer: 10413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// CaptureStdout - starts capturing stdout. 10423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetCapturedStdout - stops capturing stdout and returns the captured string. 10433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// CaptureStderr - starts capturing stderr. 10443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GetCapturedStderr - stops capturing stderr and returns the captured string. 10453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 10463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ void CaptureStdout(); 10473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ String GetCapturedStdout(); 10483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ void CaptureStderr(); 10493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ String GetCapturedStderr(); 10503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_STREAM_REDIRECTION 10523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_DEATH_TEST 10553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A copy of all command line arguments. Set by InitGoogleTest(). 10573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickextern ::std::vector<String> g_argvs; 10583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_HAS_DEATH_TEST implies we have ::std::string. 10603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickconst ::std::vector<String>& GetArgvs(); 10613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_DEATH_TEST 10633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines synchronization primitives. 10653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_HAS_PTHREAD 10673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Sleeps for (roughly) n milli-seconds. This function is only for 10693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// testing Google Test's own constructs. Don't use it in user tests, 10703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// either directly or indirectly. 10713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline void SleepMilliseconds(int n) { 10723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const timespec time = { 10733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 0, // 0 seconds. 10743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick n * 1000L * 1000L, // And n ms. 10753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick }; 10763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick nanosleep(&time, NULL); 10773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 10783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Allows a controller thread to pause execution of newly created 10803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// threads until notified. Instances of this class must be created 10813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// and destroyed in the controller thread. 10823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 10833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This class is only for testing Google Test's own constructs. Do not 10843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// use it in user tests, either directly or indirectly. 10853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass Notification { 10863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 10873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick Notification() : notified_(false) {} 10883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Notifies all threads created with this notification to start. Must 10903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // be called from the controller thread. 10913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void Notify() { notified_ = true; } 10923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 10933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Blocks until the controller thread notifies. Must be called from a test 10943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // thread. 10953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void WaitForNotification() { 10963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick while(!notified_) { 10973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick SleepMilliseconds(10); 10983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 10993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 11003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 11023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick volatile bool notified_; 11033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 11053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 11063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. 11083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Consequently, it cannot select a correct instantiation of ThreadWithParam 11093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// in order to call its Run(). Introducing ThreadWithParamBase as a 11103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// non-templated base class for ThreadWithParam allows us to bypass this 11113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// problem. 11123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass ThreadWithParamBase { 11133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 11143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick virtual ~ThreadWithParamBase() {} 11153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick virtual void Run() = 0; 11163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 11173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// pthread_create() accepts a pointer to a function type with the C linkage. 11193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// According to the Standard (7.5/1), function types with different linkages 11203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// are different even if they are otherwise identical. Some compilers (for 11213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// example, SunStudio) treat them as different types. Since class methods 11223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// cannot be defined with C-linkage we need to define a free C-function to 11233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// pass into pthread_create(). 11243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickextern "C" inline void* ThreadFuncWithCLinkage(void* thread) { 11253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static_cast<ThreadWithParamBase*>(thread)->Run(); 11263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return NULL; 11273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 11283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Helper class for testing Google Test's multi-threading constructs. 11303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// To use it, write: 11313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// void ThreadFunc(int param) { /* Do things with param */ } 11333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Notification thread_can_start; 11343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ... 11353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // The thread_can_start parameter is optional; you can supply NULL. 11363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); 11373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// thread_can_start.Notify(); 11383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// These classes are only for testing Google Test's own constructs. Do 11403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// not use them in user tests, either directly or indirectly. 11413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 11423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass ThreadWithParam : public ThreadWithParamBase { 11433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 11443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef void (*UserThreadFunc)(T); 11453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadWithParam( 11473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick UserThreadFunc func, T param, Notification* thread_can_start) 11483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick : func_(func), 11493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick param_(param), 11503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick thread_can_start_(thread_can_start), 11513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick finished_(false) { 11523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadWithParamBase* const base = this; 11533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // The thread can be created only after all fields except thread_ 11543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // have been initialized. 11553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_( 11563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); 11573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 11583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~ThreadWithParam() { Join(); } 11593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void Join() { 11613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (!finished_) { 11623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); 11633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick finished_ = true; 11643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 11653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 11663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick virtual void Run() { 11683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (thread_can_start_ != NULL) 11693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick thread_can_start_->WaitForNotification(); 11703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick func_(param_); 11713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 11723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 11743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const UserThreadFunc func_; // User-supplied thread function. 11753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T param_; // User-supplied parameter to the thread function. 11763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // When non-NULL, used to block execution until the controller thread 11773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // notifies. 11783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick Notification* const thread_can_start_; 11793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick bool finished_; // true iff we know that the thread function has finished. 11803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_t thread_; // The native thread object. 11813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 11833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 11843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 11853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// MutexBase and Mutex implement mutex on pthreads-based platforms. They 11863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// are used in conjunction with class MutexLock: 11873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Mutex mutex; 11893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ... 11903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end 11913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // of the current scope. 11923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// MutexBase implements behavior for both statically and dynamically 11943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// allocated mutexes. Do not use MutexBase directly. Instead, write 11953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// the following to define a static mutex: 11963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); 11983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 11993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// You can forward declare a static mutex like this: 12003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 12013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); 12023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 12033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// To create a dynamic mutex, just define an object of type Mutex. 12043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass MutexBase { 12053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 12063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Acquires this mutex. 12073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void Lock() { 12083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); 12093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick owner_ = pthread_self(); 12103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 12113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Releases this mutex. 12133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void Unlock() { 12143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // We don't protect writing to owner_ here, as it's the caller's 12153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // responsibility to ensure that the current thread holds the 12163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // mutex when this is called. 12173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick owner_ = 0; 12183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); 12193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 12203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Does nothing if the current thread holds the mutex. Otherwise, crashes 12223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // with high probability. 12233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void AssertHeld() const { 12243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_(owner_ == pthread_self()) 12253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick << "The current thread is not holding the mutex @" << this; 12263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 12273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // A static mutex may be used before main() is entered. It may even 12293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // be used before the dynamic initialization stage. Therefore we 12303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // must be able to initialize a static mutex object at link time. 12313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // This means MutexBase has to be a POD and its member variables 12323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // have to be public. 12333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 12343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_mutex_t mutex_; // The underlying pthread mutex. 12353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_t owner_; // The thread holding the mutex; 0 means no one holds it. 12363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 12373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Forward-declares a static mutex. 12393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 12403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick extern ::testing::internal::MutexBase mutex 12413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Defines and statically (i.e. at link time) initializes a static mutex. 12433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 12443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 } 12453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The Mutex class can only be used for mutexes created at runtime. It 12473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// shares its API with MutexBase otherwise. 12483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass Mutex : public MutexBase { 12493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 12503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick Mutex() { 12513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 12523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick owner_ = 0; 12533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 12543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~Mutex() { 12553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); 12563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 12573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 12593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 12603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 12613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// We cannot name this class MutexLock as the ctor declaration would 12633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// conflict with a macro named MutexLock, which is defined on some 12643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// platforms. Hence the typedef trick below. 12653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass GTestMutexLock { 12663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 12673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit GTestMutexLock(MutexBase* mutex) 12683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick : mutex_(mutex) { mutex_->Lock(); } 12693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~GTestMutexLock() { mutex_->Unlock(); } 12713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 12733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick MutexBase* const mutex_; 12743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 12763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 12773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef GTestMutexLock MutexLock; 12793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Helpers for ThreadLocal. 12813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// pthread_key_create() requires DeleteThreadLocalValue() to have 12833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// C-linkage. Therefore it cannot be templatized to access 12843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ThreadLocal<T>. Hence the need for class 12853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ThreadLocalValueHolderBase. 12863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass ThreadLocalValueHolderBase { 12873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 12883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick virtual ~ThreadLocalValueHolderBase() {} 12893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 12903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Called by pthread to delete thread-local data stored by 12923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// pthread_setspecific(). 12933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickextern "C" inline void DeleteThreadLocalValue(void* value_holder) { 12943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick delete static_cast<ThreadLocalValueHolderBase*>(value_holder); 12953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 12963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 12973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Implements thread-local storage on pthreads-based systems. 12983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 12993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // Thread 1 13003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ThreadLocal<int> tl(100); // 100 is the default value for each thread. 13013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 13023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // Thread 2 13033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// tl.set(150); // Changes the value for thread 2 only. 13043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// EXPECT_EQ(150, tl.get()); 13053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 13063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// // Thread 1 13073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. 13083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// tl.set(200); 13093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// EXPECT_EQ(200, tl.get()); 13103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 13113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The template type argument T must have a public copy constructor. 13123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// In addition, the default ThreadLocal constructor requires T to have 13133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// a public default constructor. 13143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 13153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// An object managed for a thread by a ThreadLocal instance is deleted 13163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// when the thread exits. Or, if the ThreadLocal instance dies in 13173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// that thread, when the ThreadLocal dies. It's the user's 13183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// responsibility to ensure that all other threads using a ThreadLocal 13193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// have exited when it dies, or the per-thread objects for those 13203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// threads will not be deleted. 13213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 13223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Google Test only uses global ThreadLocal objects. That means they 13233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// will die after main() has returned. Therefore, no per-thread 13243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// object managed by Google Test will be leaked as long as all threads 13253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// using Google Test have exited when main() returns. 13263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 13273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass ThreadLocal { 13283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 13293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadLocal() : key_(CreateKey()), 13303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick default_() {} 13313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit ThreadLocal(const T& value) : key_(CreateKey()), 13323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick default_(value) {} 13333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~ThreadLocal() { 13353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Destroys the managed object for the current thread, if any. 13363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick DeleteThreadLocalValue(pthread_getspecific(key_)); 13373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Releases resources associated with the key. This will *not* 13393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // delete managed objects for other threads. 13403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); 13413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 13423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* pointer() { return GetOrCreateValue(); } 13443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T* pointer() const { return GetOrCreateValue(); } 13453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T& get() const { return *pointer(); } 13463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void set(const T& value) { *pointer() = value; } 13473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 13493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Holds a value of type T. 13503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick class ValueHolder : public ThreadLocalValueHolderBase { 13513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 13523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit ValueHolder(const T& value) : value_(value) {} 13533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* pointer() { return &value_; } 13553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 13573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T value_; 13583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 13593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick }; 13603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static pthread_key_t CreateKey() { 13623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_key_t key; 13633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // When a thread exits, DeleteThreadLocalValue() will be called on 13643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // the object managed for that thread. 13653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_( 13663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick pthread_key_create(&key, &DeleteThreadLocalValue)); 13673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return key; 13683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 13693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* GetOrCreateValue() const { 13713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadLocalValueHolderBase* const holder = 13723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); 13733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick if (holder != NULL) { 13743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); 13753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 13763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ValueHolder* const new_holder = new ValueHolder(default_); 13783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadLocalValueHolderBase* const holder_base = new_holder; 13793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); 13803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return new_holder->pointer(); 13813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick } 13823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // A key pthreads uses for looking up per-thread values. 13843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const pthread_key_t key_; 13853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T default_; // The default value for each thread. 13863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 13883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 13893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_IS_THREADSAFE 1 13913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else // GTEST_HAS_PTHREAD 13933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// A dummy implementation of synchronization primitives (mutex, lock, 13953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// and thread-local variable). Necessary for compiling Google Test where 13963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// mutex is not supported - using Google Test in multiple threads is not 13973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// supported on such platforms. 13983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 13993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass Mutex { 14003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 14013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick Mutex() {} 14023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void AssertHeld() const {} 14033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 14063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick extern ::testing::internal::Mutex mutex 14073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 14093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass GTestMutexLock { 14113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 14123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit GTestMutexLock(Mutex*) {} // NOLINT 14133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef GTestMutexLock MutexLock; 14163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 14183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass ThreadLocal { 14193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 14203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ThreadLocal() : value_() {} 14213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick explicit ThreadLocal(const T& value) : value_(value) {} 14223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T* pointer() { return &value_; } 14233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T* pointer() const { return &value_; } 14243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const T& get() const { return value_; } 14253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick void set(const T& value) { value_ = value; } 14263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick private: 14273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick T value_; 14283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The above synchronization primitives have dummy implementations. 14313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Therefore Google Test is not thread-safe. 14323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_IS_THREADSAFE 0 14333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_HAS_PTHREAD 14353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Returns the number of threads running in the process, or 0 to indicate that 14373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// we cannot detect it. 14383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ size_t GetThreadCount(); 14393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Passing non-POD classes through ellipsis (...) crashes the ARM 14413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// compiler and generates a warning in Sun Studio. The Nokia Symbian 14423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// and the IBM XL C/C++ compiler try to instantiate a copy constructor 14433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// for objects passed through ellipsis (...), failing for uncopyable 14443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// objects. We define this to ensure that only POD is passed through 14453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ellipsis on these systems. 14463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 14473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// We lose support for NULL detection where the compiler doesn't like 14483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// passing non-POD classes through ellipsis (...). 14493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_ELLIPSIS_NEEDS_POD_ 1 14503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 14513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_CAN_COMPARE_NULL 1 14523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 14533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 14553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// const T& and const T* in a function template. These compilers 14563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// _can_ decide between class template specializations for T and T*, 14573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// so a tr1::type_traits-like is_pointer works. 14583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 14593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_NEEDS_IS_POINTER_ 1 14603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 14613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <bool bool_value> 14633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct bool_constant { 14643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef bool_constant<bool_value> type; 14653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick static const bool value = bool_value; 14663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <bool bool_value> const bool bool_constant<bool_value>::value; 14683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef bool_constant<false> false_type; 14703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef bool_constant<true> true_type; 14713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 14733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct is_pointer : public false_type {}; 14743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 14763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct is_pointer<T*> : public true_type {}; 14773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename Iterator> 14793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct IteratorTraits { 14803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef typename Iterator::value_type value_type; 14813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 14843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct IteratorTraits<T*> { 14853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef T value_type; 14863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <typename T> 14893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickstruct IteratorTraits<const T*> { 14903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef T value_type; 14913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 14923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 14933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_WINDOWS 14943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_PATH_SEP_ "\\" 14953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_ALT_PATH_SEP_ 1 14963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The biggest signed integer type the compiler supports. 14973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef __int64 BiggestInt; 14983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 14993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_PATH_SEP_ "/" 15003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# define GTEST_HAS_ALT_PATH_SEP_ 0 15013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef long long BiggestInt; // NOLINT 15023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_OS_WINDOWS 15033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Utilities for char. 15053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// isspace(int ch) and friends accept an unsigned char or EOF. char 15073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// may be signed, depending on the compiler (or compiler flags). 15083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Therefore we need to cast a char to unsigned char before calling 15093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// isspace(), etc. 15103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsAlpha(char ch) { 15123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isalpha(static_cast<unsigned char>(ch)) != 0; 15133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsAlNum(char ch) { 15153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isalnum(static_cast<unsigned char>(ch)) != 0; 15163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsDigit(char ch) { 15183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isdigit(static_cast<unsigned char>(ch)) != 0; 15193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsLower(char ch) { 15213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return islower(static_cast<unsigned char>(ch)) != 0; 15223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsSpace(char ch) { 15243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isspace(static_cast<unsigned char>(ch)) != 0; 15253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsUpper(char ch) { 15273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isupper(static_cast<unsigned char>(ch)) != 0; 15283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsXDigit(char ch) { 15303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return isxdigit(static_cast<unsigned char>(ch)) != 0; 15313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline char ToLower(char ch) { 15343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<char>(tolower(static_cast<unsigned char>(ch))); 15353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline char ToUpper(char ch) { 15373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<char>(toupper(static_cast<unsigned char>(ch))); 15383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The testing::internal::posix namespace holds wrappers for common 15413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// POSIX functions. These wrappers hide the differences between 15423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Windows/MSVC and POSIX systems. Since some compilers define these 15433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// standard functions as macros, the wrapper cannot have the same name 15443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// as the wrapped function. 15453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicknamespace posix { 15473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Functions with a different name on Windows. 15493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_WINDOWS 15513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef struct _stat StatStruct; 15533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# ifdef __BORLANDC__ 15553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int IsATTY(int fd) { return isatty(fd); } 15563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int StrCaseCmp(const char* s1, const char* s2) { 15573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return stricmp(s1, s2); 15583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline char* StrDup(const char* src) { return strdup(src); } 15603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else // !__BORLANDC__ 15613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_OS_WINDOWS_MOBILE 15623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int IsATTY(int /* fd */) { return 0; } 15633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 15643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int IsATTY(int fd) { return _isatty(fd); } 15653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // GTEST_OS_WINDOWS_MOBILE 15663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int StrCaseCmp(const char* s1, const char* s2) { 15673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return _stricmp(s1, s2); 15683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline char* StrDup(const char* src) { return _strdup(src); } 15703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // __BORLANDC__ 15713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# if GTEST_OS_WINDOWS_MOBILE 15733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 15743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 15753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// time and thus not defined there. 15763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# else 15773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int FileNo(FILE* file) { return _fileno(file); } 15783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 15793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int RmDir(const char* dir) { return _rmdir(dir); } 15803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsDir(const StatStruct& st) { 15813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return (_S_IFDIR & st.st_mode) != 0; 15823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# endif // GTEST_OS_WINDOWS_MOBILE 15843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 15863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef struct stat StatStruct; 15883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int FileNo(FILE* file) { return fileno(file); } 15903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int IsATTY(int fd) { return isatty(fd); } 15913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 15923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int StrCaseCmp(const char* s1, const char* s2) { 15933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return strcasecmp(s1, s2); 15943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 15953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline char* StrDup(const char* src) { return strdup(src); } 15963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int RmDir(const char* dir) { return rmdir(dir); } 15973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 15983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 15993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_OS_WINDOWS 16003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Functions deprecated by MSVC 8.0. 16023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef _MSC_VER 16043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Temporarily disable warning 4996 (deprecated function). 16053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# pragma warning(push) 16063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# pragma warning(disable:4996) 16073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline const char* StrNCpy(char* dest, const char* src, size_t n) { 16103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return strncpy(dest, src, n); 16113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 16143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// StrError() aren't needed on Windows CE at this time and thus not 16153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// defined there. 16163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if !GTEST_OS_WINDOWS_MOBILE 16183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int ChDir(const char* dir) { return chdir(dir); } 16193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline FILE* FOpen(const char* path, const char* mode) { 16213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return fopen(path, mode); 16223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if !GTEST_OS_WINDOWS_MOBILE 16243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 16253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return freopen(path, mode, stream); 16263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 16283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int FClose(FILE* fp) { return fclose(fp); } 16303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if !GTEST_OS_WINDOWS_MOBILE 16313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int Read(int fd, void* buf, unsigned int count) { 16323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<int>(read(fd, buf, count)); 16333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int Write(int fd, const void* buf, unsigned int count) { 16353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return static_cast<int>(write(fd, buf, count)); 16363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline int Close(int fd) { return close(fd); } 16383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline const char* StrError(int errnum) { return strerror(errnum); } 16393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline const char* GetEnv(const char* name) { 16413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_WINDOWS_MOBILE 16423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // We are on Windows CE, which has no environment variables. 16433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return NULL; 16443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 16453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // Environment variables which we programmatically clear will be set to the 16463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // empty string rather than unset (NULL). Handle that case. 16473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick const char* const env = getenv(name); 16483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return (env != NULL && env[0] != '\0') ? env : NULL; 16493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 16503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick return getenv(name); 16513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} 16533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#ifdef _MSC_VER 16553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick# pragma warning(pop) // Restores the warning state. 16563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif 16573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_WINDOWS_MOBILE 16593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Windows CE has no C library. The abort() function is used in 16603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// several places in Google Test. This implementation provides a reasonable 16613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// imitation of standard behaviour. 16623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickvoid Abort(); 16633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 16643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickinline void Abort() { abort(); } 16653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_OS_WINDOWS_MOBILE 16663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} // namespace posix 16683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The maximum number a BiggestInt can represent. This definition 16703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// works no matter BiggestInt is represented in one's complement or 16713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// two's complement. 16723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// We cannot rely on numeric_limits in STL, as __int64 and long long 16743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// are not part of standard C++ and numeric_limits doesn't need to be 16753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// defined for them. 16763d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickconst BiggestInt kMaxBiggestInt = 16773d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 16783d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 16793d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// This template class serves as a compile-time function from size to 16803d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// type. It maps a size in bytes to a primitive type with that 16813d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// size. e.g. 16823d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16833d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// TypeWithSize<4>::UInt 16843d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16853d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// is typedef-ed to be unsigned int (unsigned integer made up of 4 16863d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// bytes). 16873d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16883d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Such functionality should belong to STL, but I cannot find it 16893d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// there. 16903d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16913d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Google Test uses this class in the implementation of floating-point 16923d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// comparison. 16933d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// 16943d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// For now it only handles UInt (unsigned int) as that's all Google Test 16953d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// needs. Other types can be easily added in the future if need 16963d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// arises. 16973d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <size_t size> 16983d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass TypeWithSize { 16993d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 17003d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // This prevents the user from using TypeWithSize<N> with incorrect 17013d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // values of N. 17023d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef void UInt; 17033d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 17043d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17053d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The specialization for size 4. 17063d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <> 17073d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass TypeWithSize<4> { 17083d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 17093d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // unsigned int has size 4 in both gcc and MSVC. 17103d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // 17113d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // As base/basictypes.h doesn't compile on Windows, we cannot use 17123d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick // uint32, uint64, and etc here. 17133d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef int Int; 17143d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef unsigned int UInt; 17153d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 17163d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17173d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// The specialization for size 8. 17183d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktemplate <> 17193d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickclass TypeWithSize<8> { 17203d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick public: 17213d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17223d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#if GTEST_OS_WINDOWS 17233d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef __int64 Int; 17243d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef unsigned __int64 UInt; 17253d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#else 17263d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef long long Int; // NOLINT 17273d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick typedef unsigned long long UInt; // NOLINT 17283d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_OS_WINDOWS 17293d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick}; 17303d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17313d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Integer types of known sizes. 17323d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef TypeWithSize<4>::Int Int32; 17333d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef TypeWithSize<4>::UInt UInt32; 17343d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef TypeWithSize<8>::Int Int64; 17353d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef TypeWithSize<8>::UInt UInt64; 17363d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanicktypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 17373d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17383d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Utilities for command line flags and environment variables. 17393d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17403d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macro for referencing flags. 17413d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_FLAG(name) FLAGS_gtest_##name 17423d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17433d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macros for declaring flags. 17443d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 17453d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DECLARE_int32_(name) \ 17463d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 17473d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DECLARE_string_(name) \ 17483d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name) 17493d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17503d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Macros for defining flags. 17513d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DEFINE_bool_(name, default_val, doc) \ 17523d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_API_ bool GTEST_FLAG(name) = (default_val) 17533d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DEFINE_int32_(name, default_val, doc) \ 17543d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 17553d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#define GTEST_DEFINE_string_(name, default_val, doc) \ 17563d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val) 17573d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17583d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Parses 'str' for a 32-bit signed integer. If successful, writes the result 17593d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// to *value and returns true; otherwise leaves *value unchanged and returns 17603d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// false. 17613d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// TODO(chandlerc): Find a better way to refactor flag and environment parsing 17623d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 17633d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// function. 17643d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickbool ParseInt32(const Message& src_text, const char* str, Int32* value); 17653d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17663d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// Parses a bool/Int32/string from the environment variable 17673d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick// corresponding to the given Google Test flag. 17683d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickbool BoolFromGTestEnv(const char* flag, bool default_val); 17693d000e7dd14c3185b9e27a6c38a67288b4d10431Ian RomanickGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 17703d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanickconst char* StringFromGTestEnv(const char* flag, const char* default_val); 17713d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17723d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} // namespace internal 17733d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick} // namespace testing 17743d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick 17753d000e7dd14c3185b9e27a6c38a67288b4d10431Ian Romanick#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 1776