113481Sgiacomo.travaglini@arm.com// Copyright 2005, Google Inc. 213481Sgiacomo.travaglini@arm.com// All rights reserved. 313481Sgiacomo.travaglini@arm.com// 413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 613481Sgiacomo.travaglini@arm.com// met: 713481Sgiacomo.travaglini@arm.com// 813481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1013481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1313481Sgiacomo.travaglini@arm.com// distribution. 1413481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 1713481Sgiacomo.travaglini@arm.com// 1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2913481Sgiacomo.travaglini@arm.com// 3013481Sgiacomo.travaglini@arm.com// Authors: wan@google.com (Zhanyong Wan) 3113481Sgiacomo.travaglini@arm.com// 3213481Sgiacomo.travaglini@arm.com// Low-level types and utilities for porting Google Test to various 3313481Sgiacomo.travaglini@arm.com// platforms. All macros ending with _ and symbols defined in an 3413481Sgiacomo.travaglini@arm.com// internal namespace are subject to change without notice. Code 3513481Sgiacomo.travaglini@arm.com// outside Google Test MUST NOT USE THEM DIRECTLY. Macros that don't 3613481Sgiacomo.travaglini@arm.com// end with _ are part of Google Test's public API and can be used by 3713481Sgiacomo.travaglini@arm.com// code outside Google Test. 3813481Sgiacomo.travaglini@arm.com// 3913481Sgiacomo.travaglini@arm.com// This file is fundamental to Google Test. All other Google Test source 4013481Sgiacomo.travaglini@arm.com// files are expected to #include this. Therefore, it cannot #include 4113481Sgiacomo.travaglini@arm.com// any other Google Test header. 4213481Sgiacomo.travaglini@arm.com 4313481Sgiacomo.travaglini@arm.com#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 4413481Sgiacomo.travaglini@arm.com#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 4513481Sgiacomo.travaglini@arm.com 4613481Sgiacomo.travaglini@arm.com// Environment-describing macros 4713481Sgiacomo.travaglini@arm.com// ----------------------------- 4813481Sgiacomo.travaglini@arm.com// 4913481Sgiacomo.travaglini@arm.com// Google Test can be used in many different environments. Macros in 5013481Sgiacomo.travaglini@arm.com// this section tell Google Test what kind of environment it is being 5113481Sgiacomo.travaglini@arm.com// used in, such that Google Test can provide environment-specific 5213481Sgiacomo.travaglini@arm.com// features and implementations. 5313481Sgiacomo.travaglini@arm.com// 5413481Sgiacomo.travaglini@arm.com// Google Test tries to automatically detect the properties of its 5513481Sgiacomo.travaglini@arm.com// environment, so users usually don't need to worry about these 5613481Sgiacomo.travaglini@arm.com// macros. However, the automatic detection is not perfect. 5713481Sgiacomo.travaglini@arm.com// Sometimes it's necessary for a user to define some of the following 5813481Sgiacomo.travaglini@arm.com// macros in the build script to override Google Test's decisions. 5913481Sgiacomo.travaglini@arm.com// 6013481Sgiacomo.travaglini@arm.com// If the user doesn't define a macro in the list, Google Test will 6113481Sgiacomo.travaglini@arm.com// provide a default definition. After this header is #included, all 6213481Sgiacomo.travaglini@arm.com// macros in this list will be defined to either 1 or 0. 6313481Sgiacomo.travaglini@arm.com// 6413481Sgiacomo.travaglini@arm.com// Notes to maintainers: 6513481Sgiacomo.travaglini@arm.com// - Each macro here is a user-tweakable knob; do not grow the list 6613481Sgiacomo.travaglini@arm.com// lightly. 6713481Sgiacomo.travaglini@arm.com// - Use #if to key off these macros. Don't use #ifdef or "#if 6813481Sgiacomo.travaglini@arm.com// defined(...)", which will not work as these macros are ALWAYS 6913481Sgiacomo.travaglini@arm.com// defined. 7013481Sgiacomo.travaglini@arm.com// 7113481Sgiacomo.travaglini@arm.com// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 7213481Sgiacomo.travaglini@arm.com// is/isn't available. 7313481Sgiacomo.travaglini@arm.com// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions 7413481Sgiacomo.travaglini@arm.com// are enabled. 7513481Sgiacomo.travaglini@arm.com// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 7613481Sgiacomo.travaglini@arm.com// is/isn't available (some systems define 7713481Sgiacomo.travaglini@arm.com// ::string, which is different to std::string). 7813481Sgiacomo.travaglini@arm.com// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 7913481Sgiacomo.travaglini@arm.com// is/isn't available (some systems define 8013481Sgiacomo.travaglini@arm.com// ::wstring, which is different to std::wstring). 8113481Sgiacomo.travaglini@arm.com// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular 8213481Sgiacomo.travaglini@arm.com// expressions are/aren't available. 8313481Sgiacomo.travaglini@arm.com// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 8413481Sgiacomo.travaglini@arm.com// is/isn't available. 8513481Sgiacomo.travaglini@arm.com// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 8613481Sgiacomo.travaglini@arm.com// enabled. 8713481Sgiacomo.travaglini@arm.com// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 8813481Sgiacomo.travaglini@arm.com// std::wstring does/doesn't work (Google Test can 8913481Sgiacomo.travaglini@arm.com// be used where std::wstring is unavailable). 9013481Sgiacomo.travaglini@arm.com// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 9113481Sgiacomo.travaglini@arm.com// is/isn't available. 9213481Sgiacomo.travaglini@arm.com// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 9313481Sgiacomo.travaglini@arm.com// compiler supports Microsoft's "Structured 9413481Sgiacomo.travaglini@arm.com// Exception Handling". 9513481Sgiacomo.travaglini@arm.com// GTEST_HAS_STREAM_REDIRECTION 9613481Sgiacomo.travaglini@arm.com// - Define it to 1/0 to indicate whether the 9713481Sgiacomo.travaglini@arm.com// platform supports I/O stream redirection using 9813481Sgiacomo.travaglini@arm.com// dup() and dup2(). 9913481Sgiacomo.travaglini@arm.com// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 10013481Sgiacomo.travaglini@arm.com// Test's own tr1 tuple implementation should be 10113481Sgiacomo.travaglini@arm.com// used. Unused when the user sets 10213481Sgiacomo.travaglini@arm.com// GTEST_HAS_TR1_TUPLE to 0. 10313481Sgiacomo.travaglini@arm.com// GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test 10413481Sgiacomo.travaglini@arm.com// is building in C++11/C++98 mode. 10513481Sgiacomo.travaglini@arm.com// GTEST_LINKED_AS_SHARED_LIBRARY 10613481Sgiacomo.travaglini@arm.com// - Define to 1 when compiling tests that use 10713481Sgiacomo.travaglini@arm.com// Google Test as a shared library (known as 10813481Sgiacomo.travaglini@arm.com// DLL on Windows). 10913481Sgiacomo.travaglini@arm.com// GTEST_CREATE_SHARED_LIBRARY 11013481Sgiacomo.travaglini@arm.com// - Define to 1 when compiling Google Test itself 11113481Sgiacomo.travaglini@arm.com// as a shared library. 11213481Sgiacomo.travaglini@arm.com 11313481Sgiacomo.travaglini@arm.com// Platform-indicating macros 11413481Sgiacomo.travaglini@arm.com// -------------------------- 11513481Sgiacomo.travaglini@arm.com// 11613481Sgiacomo.travaglini@arm.com// Macros indicating the platform on which Google Test is being used 11713481Sgiacomo.travaglini@arm.com// (a macro is defined to 1 if compiled on the given platform; 11813481Sgiacomo.travaglini@arm.com// otherwise UNDEFINED -- it's never defined to 0.). Google Test 11913481Sgiacomo.travaglini@arm.com// defines these macros automatically. Code outside Google Test MUST 12013481Sgiacomo.travaglini@arm.com// NOT define them. 12113481Sgiacomo.travaglini@arm.com// 12213481Sgiacomo.travaglini@arm.com// GTEST_OS_AIX - IBM AIX 12313481Sgiacomo.travaglini@arm.com// GTEST_OS_CYGWIN - Cygwin 12413481Sgiacomo.travaglini@arm.com// GTEST_OS_FREEBSD - FreeBSD 12513481Sgiacomo.travaglini@arm.com// GTEST_OS_HPUX - HP-UX 12613481Sgiacomo.travaglini@arm.com// GTEST_OS_LINUX - Linux 12713481Sgiacomo.travaglini@arm.com// GTEST_OS_LINUX_ANDROID - Google Android 12813481Sgiacomo.travaglini@arm.com// GTEST_OS_MAC - Mac OS X 12913481Sgiacomo.travaglini@arm.com// GTEST_OS_IOS - iOS 13013481Sgiacomo.travaglini@arm.com// GTEST_OS_NACL - Google Native Client (NaCl) 13113481Sgiacomo.travaglini@arm.com// GTEST_OS_OPENBSD - OpenBSD 13213481Sgiacomo.travaglini@arm.com// GTEST_OS_QNX - QNX 13313481Sgiacomo.travaglini@arm.com// GTEST_OS_SOLARIS - Sun Solaris 13413481Sgiacomo.travaglini@arm.com// GTEST_OS_SYMBIAN - Symbian 13513481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 13613481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 13713481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS_MINGW - MinGW 13813481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS_MOBILE - Windows Mobile 13913481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS_PHONE - Windows Phone 14013481Sgiacomo.travaglini@arm.com// GTEST_OS_WINDOWS_RT - Windows Store App/WinRT 14113481Sgiacomo.travaglini@arm.com// GTEST_OS_ZOS - z/OS 14213481Sgiacomo.travaglini@arm.com// 14313481Sgiacomo.travaglini@arm.com// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 14413481Sgiacomo.travaglini@arm.com// most stable support. Since core members of the Google Test project 14513481Sgiacomo.travaglini@arm.com// don't have access to other platforms, support for them may be less 14613481Sgiacomo.travaglini@arm.com// stable. If you notice any problems on your platform, please notify 14713481Sgiacomo.travaglini@arm.com// googletestframework@googlegroups.com (patches for fixing them are 14813481Sgiacomo.travaglini@arm.com// even more welcome!). 14913481Sgiacomo.travaglini@arm.com// 15013481Sgiacomo.travaglini@arm.com// It is possible that none of the GTEST_OS_* macros are defined. 15113481Sgiacomo.travaglini@arm.com 15213481Sgiacomo.travaglini@arm.com// Feature-indicating macros 15313481Sgiacomo.travaglini@arm.com// ------------------------- 15413481Sgiacomo.travaglini@arm.com// 15513481Sgiacomo.travaglini@arm.com// Macros indicating which Google Test features are available (a macro 15613481Sgiacomo.travaglini@arm.com// is defined to 1 if the corresponding feature is supported; 15713481Sgiacomo.travaglini@arm.com// otherwise UNDEFINED -- it's never defined to 0.). Google Test 15813481Sgiacomo.travaglini@arm.com// defines these macros automatically. Code outside Google Test MUST 15913481Sgiacomo.travaglini@arm.com// NOT define them. 16013481Sgiacomo.travaglini@arm.com// 16113481Sgiacomo.travaglini@arm.com// These macros are public so that portable tests can be written. 16213481Sgiacomo.travaglini@arm.com// Such tests typically surround code using a feature with an #if 16313481Sgiacomo.travaglini@arm.com// which controls that code. For example: 16413481Sgiacomo.travaglini@arm.com// 16513481Sgiacomo.travaglini@arm.com// #if GTEST_HAS_DEATH_TEST 16613481Sgiacomo.travaglini@arm.com// EXPECT_DEATH(DoSomethingDeadly()); 16713481Sgiacomo.travaglini@arm.com// #endif 16813481Sgiacomo.travaglini@arm.com// 16913481Sgiacomo.travaglini@arm.com// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 17013481Sgiacomo.travaglini@arm.com// tests) 17113481Sgiacomo.travaglini@arm.com// GTEST_HAS_DEATH_TEST - death tests 17213481Sgiacomo.travaglini@arm.com// GTEST_HAS_PARAM_TEST - value-parameterized tests 17313481Sgiacomo.travaglini@arm.com// GTEST_HAS_TYPED_TEST - typed tests 17413481Sgiacomo.travaglini@arm.com// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 17513481Sgiacomo.travaglini@arm.com// GTEST_IS_THREADSAFE - Google Test is thread-safe. 17613481Sgiacomo.travaglini@arm.com// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with 17713481Sgiacomo.travaglini@arm.com// GTEST_HAS_POSIX_RE (see above) which users can 17813481Sgiacomo.travaglini@arm.com// define themselves. 17913481Sgiacomo.travaglini@arm.com// GTEST_USES_SIMPLE_RE - our own simple regex is used; 18013481Sgiacomo.travaglini@arm.com// the above two are mutually exclusive. 18113481Sgiacomo.travaglini@arm.com// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). 18213481Sgiacomo.travaglini@arm.com 18313481Sgiacomo.travaglini@arm.com// Misc public macros 18413481Sgiacomo.travaglini@arm.com// ------------------ 18513481Sgiacomo.travaglini@arm.com// 18613481Sgiacomo.travaglini@arm.com// GTEST_FLAG(flag_name) - references the variable corresponding to 18713481Sgiacomo.travaglini@arm.com// the given Google Test flag. 18813481Sgiacomo.travaglini@arm.com 18913481Sgiacomo.travaglini@arm.com// Internal utilities 19013481Sgiacomo.travaglini@arm.com// ------------------ 19113481Sgiacomo.travaglini@arm.com// 19213481Sgiacomo.travaglini@arm.com// The following macros and utilities are for Google Test's INTERNAL 19313481Sgiacomo.travaglini@arm.com// use only. Code outside Google Test MUST NOT USE THEM DIRECTLY. 19413481Sgiacomo.travaglini@arm.com// 19513481Sgiacomo.travaglini@arm.com// Macros for basic C++ coding: 19613481Sgiacomo.travaglini@arm.com// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 19713481Sgiacomo.travaglini@arm.com// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 19813481Sgiacomo.travaglini@arm.com// variable don't have to be used. 19913481Sgiacomo.travaglini@arm.com// GTEST_DISALLOW_ASSIGN_ - disables operator=. 20013481Sgiacomo.travaglini@arm.com// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 20113481Sgiacomo.travaglini@arm.com// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 20213481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is 20313481Sgiacomo.travaglini@arm.com// suppressed (constant conditional). 20413481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_POP_ - finish code section where MSVC C4127 20513481Sgiacomo.travaglini@arm.com// is suppressed. 20613481Sgiacomo.travaglini@arm.com// 20713481Sgiacomo.travaglini@arm.com// C++11 feature wrappers: 20813481Sgiacomo.travaglini@arm.com// 20913481Sgiacomo.travaglini@arm.com// testing::internal::move - portability wrapper for std::move. 21013481Sgiacomo.travaglini@arm.com// 21113481Sgiacomo.travaglini@arm.com// Synchronization: 21213481Sgiacomo.travaglini@arm.com// Mutex, MutexLock, ThreadLocal, GetThreadCount() 21313481Sgiacomo.travaglini@arm.com// - synchronization primitives. 21413481Sgiacomo.travaglini@arm.com// 21513481Sgiacomo.travaglini@arm.com// Template meta programming: 21613481Sgiacomo.travaglini@arm.com// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 21713481Sgiacomo.travaglini@arm.com// IteratorTraits - partial implementation of std::iterator_traits, which 21813481Sgiacomo.travaglini@arm.com// is not available in libCstd when compiled with Sun C++. 21913481Sgiacomo.travaglini@arm.com// 22013481Sgiacomo.travaglini@arm.com// Smart pointers: 22113481Sgiacomo.travaglini@arm.com// scoped_ptr - as in TR2. 22213481Sgiacomo.travaglini@arm.com// 22313481Sgiacomo.travaglini@arm.com// Regular expressions: 22413481Sgiacomo.travaglini@arm.com// RE - a simple regular expression class using the POSIX 22513481Sgiacomo.travaglini@arm.com// Extended Regular Expression syntax on UNIX-like 22613481Sgiacomo.travaglini@arm.com// platforms, or a reduced regular exception syntax on 22713481Sgiacomo.travaglini@arm.com// other platforms, including Windows. 22813481Sgiacomo.travaglini@arm.com// 22913481Sgiacomo.travaglini@arm.com// Logging: 23013481Sgiacomo.travaglini@arm.com// GTEST_LOG_() - logs messages at the specified severity level. 23113481Sgiacomo.travaglini@arm.com// LogToStderr() - directs all log messages to stderr. 23213481Sgiacomo.travaglini@arm.com// FlushInfoLog() - flushes informational log messages. 23313481Sgiacomo.travaglini@arm.com// 23413481Sgiacomo.travaglini@arm.com// Stdout and stderr capturing: 23513481Sgiacomo.travaglini@arm.com// CaptureStdout() - starts capturing stdout. 23613481Sgiacomo.travaglini@arm.com// GetCapturedStdout() - stops capturing stdout and returns the captured 23713481Sgiacomo.travaglini@arm.com// string. 23813481Sgiacomo.travaglini@arm.com// CaptureStderr() - starts capturing stderr. 23913481Sgiacomo.travaglini@arm.com// GetCapturedStderr() - stops capturing stderr and returns the captured 24013481Sgiacomo.travaglini@arm.com// string. 24113481Sgiacomo.travaglini@arm.com// 24213481Sgiacomo.travaglini@arm.com// Integer types: 24313481Sgiacomo.travaglini@arm.com// TypeWithSize - maps an integer to a int type. 24413481Sgiacomo.travaglini@arm.com// Int32, UInt32, Int64, UInt64, TimeInMillis 24513481Sgiacomo.travaglini@arm.com// - integers of known sizes. 24613481Sgiacomo.travaglini@arm.com// BiggestInt - the biggest signed integer type. 24713481Sgiacomo.travaglini@arm.com// 24813481Sgiacomo.travaglini@arm.com// Command-line utilities: 24913481Sgiacomo.travaglini@arm.com// GTEST_DECLARE_*() - declares a flag. 25013481Sgiacomo.travaglini@arm.com// GTEST_DEFINE_*() - defines a flag. 25113481Sgiacomo.travaglini@arm.com// GetInjectableArgvs() - returns the command line as a vector of strings. 25213481Sgiacomo.travaglini@arm.com// 25313481Sgiacomo.travaglini@arm.com// Environment variable utilities: 25413481Sgiacomo.travaglini@arm.com// GetEnv() - gets the value of an environment variable. 25513481Sgiacomo.travaglini@arm.com// BoolFromGTestEnv() - parses a bool environment variable. 25613481Sgiacomo.travaglini@arm.com// Int32FromGTestEnv() - parses an Int32 environment variable. 25713481Sgiacomo.travaglini@arm.com// StringFromGTestEnv() - parses a string environment variable. 25813481Sgiacomo.travaglini@arm.com 25913481Sgiacomo.travaglini@arm.com#include <ctype.h> // for isspace, etc 26013481Sgiacomo.travaglini@arm.com#include <stddef.h> // for ptrdiff_t 26113481Sgiacomo.travaglini@arm.com#include <stdlib.h> 26213481Sgiacomo.travaglini@arm.com#include <stdio.h> 26313481Sgiacomo.travaglini@arm.com#include <string.h> 26413481Sgiacomo.travaglini@arm.com#ifndef _WIN32_WCE 26513481Sgiacomo.travaglini@arm.com# include <sys/types.h> 26613481Sgiacomo.travaglini@arm.com# include <sys/stat.h> 26713481Sgiacomo.travaglini@arm.com#endif // !_WIN32_WCE 26813481Sgiacomo.travaglini@arm.com 26913481Sgiacomo.travaglini@arm.com#if defined __APPLE__ 27013481Sgiacomo.travaglini@arm.com# include <AvailabilityMacros.h> 27113481Sgiacomo.travaglini@arm.com# include <TargetConditionals.h> 27213481Sgiacomo.travaglini@arm.com#endif 27313481Sgiacomo.travaglini@arm.com 27413481Sgiacomo.travaglini@arm.com#include <algorithm> // NOLINT 27513481Sgiacomo.travaglini@arm.com#include <iostream> // NOLINT 27613481Sgiacomo.travaglini@arm.com#include <sstream> // NOLINT 27713481Sgiacomo.travaglini@arm.com#include <string> // NOLINT 27813481Sgiacomo.travaglini@arm.com#include <utility> 27913481Sgiacomo.travaglini@arm.com#include <vector> // NOLINT 28013481Sgiacomo.travaglini@arm.com 28113481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-port-arch.h" 28213481Sgiacomo.travaglini@arm.com#include "gtest/internal/custom/gtest-port.h" 28313481Sgiacomo.travaglini@arm.com 28413481Sgiacomo.travaglini@arm.com#if !defined(GTEST_DEV_EMAIL_) 28513481Sgiacomo.travaglini@arm.com# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 28613481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_ "gtest_" 28713481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_DASH_ "gtest-" 28813481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 28913481Sgiacomo.travaglini@arm.com# define GTEST_NAME_ "Google Test" 29013481Sgiacomo.travaglini@arm.com# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/" 29113481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_DEV_EMAIL_) 29213481Sgiacomo.travaglini@arm.com 29313481Sgiacomo.travaglini@arm.com#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_) 29413481Sgiacomo.travaglini@arm.com# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest" 29513481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_INIT_GOOGLE_TEST_NAME_) 29613481Sgiacomo.travaglini@arm.com 29713481Sgiacomo.travaglini@arm.com// Determines the version of gcc that is used to compile this. 29813481Sgiacomo.travaglini@arm.com#ifdef __GNUC__ 29913481Sgiacomo.travaglini@arm.com// 40302 means version 4.3.2. 30013481Sgiacomo.travaglini@arm.com# define GTEST_GCC_VER_ \ 30113481Sgiacomo.travaglini@arm.com (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 30213481Sgiacomo.travaglini@arm.com#endif // __GNUC__ 30313481Sgiacomo.travaglini@arm.com 30413481Sgiacomo.travaglini@arm.com// Macros for disabling Microsoft Visual C++ warnings. 30513481Sgiacomo.travaglini@arm.com// 30613481Sgiacomo.travaglini@arm.com// GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385) 30713481Sgiacomo.travaglini@arm.com// /* code that triggers warnings C4800 and C4385 */ 30813481Sgiacomo.travaglini@arm.com// GTEST_DISABLE_MSC_WARNINGS_POP_() 30913481Sgiacomo.travaglini@arm.com#if _MSC_VER >= 1500 31013481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \ 31113481Sgiacomo.travaglini@arm.com __pragma(warning(push)) \ 31213481Sgiacomo.travaglini@arm.com __pragma(warning(disable: warnings)) 31313481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_POP_() \ 31413481Sgiacomo.travaglini@arm.com __pragma(warning(pop)) 31513481Sgiacomo.travaglini@arm.com#else 31613481Sgiacomo.travaglini@arm.com// Older versions of MSVC don't have __pragma. 31713481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) 31813481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_POP_() 31913481Sgiacomo.travaglini@arm.com#endif 32013481Sgiacomo.travaglini@arm.com 32113481Sgiacomo.travaglini@arm.com#ifndef GTEST_LANG_CXX11 32213481Sgiacomo.travaglini@arm.com// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when 32313481Sgiacomo.travaglini@arm.com// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a 32413481Sgiacomo.travaglini@arm.com// value for __cplusplus, and recent versions of clang, gcc, and 32513481Sgiacomo.travaglini@arm.com// probably other compilers set that too in C++11 mode. 32613481Sgiacomo.travaglini@arm.com# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L 32713481Sgiacomo.travaglini@arm.com// Compiling in at least C++11 mode. 32813481Sgiacomo.travaglini@arm.com# define GTEST_LANG_CXX11 1 32913481Sgiacomo.travaglini@arm.com# else 33013481Sgiacomo.travaglini@arm.com# define GTEST_LANG_CXX11 0 33113481Sgiacomo.travaglini@arm.com# endif 33213481Sgiacomo.travaglini@arm.com#endif 33313481Sgiacomo.travaglini@arm.com 33413481Sgiacomo.travaglini@arm.com// Distinct from C++11 language support, some environments don't provide 33513481Sgiacomo.travaglini@arm.com// proper C++11 library support. Notably, it's possible to build in 33613481Sgiacomo.travaglini@arm.com// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++ 33713481Sgiacomo.travaglini@arm.com// with no C++11 support. 33813481Sgiacomo.travaglini@arm.com// 33913481Sgiacomo.travaglini@arm.com// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__ 34013481Sgiacomo.travaglini@arm.com// 20110325, but maintenance releases in the 4.4 and 4.5 series followed 34113481Sgiacomo.travaglini@arm.com// this date, so check for those versions by their date stamps. 34213481Sgiacomo.travaglini@arm.com// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning 34313481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 && \ 34413481Sgiacomo.travaglini@arm.com (!defined(__GLIBCXX__) || ( \ 34513481Sgiacomo.travaglini@arm.com __GLIBCXX__ >= 20110325ul && /* GCC >= 4.6.0 */ \ 34613481Sgiacomo.travaglini@arm.com /* Blacklist of patch releases of older branches: */ \ 34713481Sgiacomo.travaglini@arm.com __GLIBCXX__ != 20110416ul && /* GCC 4.4.6 */ \ 34813481Sgiacomo.travaglini@arm.com __GLIBCXX__ != 20120313ul && /* GCC 4.4.7 */ \ 34913481Sgiacomo.travaglini@arm.com __GLIBCXX__ != 20110428ul && /* GCC 4.5.3 */ \ 35013481Sgiacomo.travaglini@arm.com __GLIBCXX__ != 20120702ul)) /* GCC 4.5.4 */ 35113481Sgiacomo.travaglini@arm.com# define GTEST_STDLIB_CXX11 1 35213481Sgiacomo.travaglini@arm.com#endif 35313481Sgiacomo.travaglini@arm.com 35413481Sgiacomo.travaglini@arm.com// Only use C++11 library features if the library provides them. 35513481Sgiacomo.travaglini@arm.com#if GTEST_STDLIB_CXX11 35613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_BEGIN_AND_END_ 1 35713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_FORWARD_LIST_ 1 35813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_FUNCTION_ 1 35913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_INITIALIZER_LIST_ 1 36013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_MOVE_ 1 36113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_SHARED_PTR_ 1 36213481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_TYPE_TRAITS_ 1 36313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_UNIQUE_PTR_ 1 36413481Sgiacomo.travaglini@arm.com#endif 36513481Sgiacomo.travaglini@arm.com 36613481Sgiacomo.travaglini@arm.com// C++11 specifies that <tuple> provides std::tuple. 36713481Sgiacomo.travaglini@arm.com// Some platforms still might not have it, however. 36813481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 36913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_TUPLE_ 1 37013481Sgiacomo.travaglini@arm.com# if defined(__clang__) 37113481Sgiacomo.travaglini@arm.com// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include 37213481Sgiacomo.travaglini@arm.com# if defined(__has_include) && !__has_include(<tuple>) 37313481Sgiacomo.travaglini@arm.com# undef GTEST_HAS_STD_TUPLE_ 37413481Sgiacomo.travaglini@arm.com# endif 37513481Sgiacomo.travaglini@arm.com# elif defined(_MSC_VER) 37613481Sgiacomo.travaglini@arm.com// Inspired by boost/config/stdlib/dinkumware.hpp 37713481Sgiacomo.travaglini@arm.com# if defined(_CPPLIB_VER) && _CPPLIB_VER < 520 37813481Sgiacomo.travaglini@arm.com# undef GTEST_HAS_STD_TUPLE_ 37913481Sgiacomo.travaglini@arm.com# endif 38013481Sgiacomo.travaglini@arm.com# elif defined(__GLIBCXX__) 38113481Sgiacomo.travaglini@arm.com// Inspired by boost/config/stdlib/libstdcpp3.hpp, 38213481Sgiacomo.travaglini@arm.com// http://gcc.gnu.org/gcc-4.2/changes.html and 38313481Sgiacomo.travaglini@arm.com// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x 38413481Sgiacomo.travaglini@arm.com# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2) 38513481Sgiacomo.travaglini@arm.com# undef GTEST_HAS_STD_TUPLE_ 38613481Sgiacomo.travaglini@arm.com# endif 38713481Sgiacomo.travaglini@arm.com# endif 38813481Sgiacomo.travaglini@arm.com#endif 38913481Sgiacomo.travaglini@arm.com 39013481Sgiacomo.travaglini@arm.com// Brings in definitions for functions used in the testing::internal::posix 39113481Sgiacomo.travaglini@arm.com// namespace (read, write, close, chdir, isatty, stat). We do not currently 39213481Sgiacomo.travaglini@arm.com// use them on Windows Mobile. 39313481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 39413481Sgiacomo.travaglini@arm.com# if !GTEST_OS_WINDOWS_MOBILE 39513481Sgiacomo.travaglini@arm.com# include <direct.h> 39613481Sgiacomo.travaglini@arm.com# include <io.h> 39713481Sgiacomo.travaglini@arm.com# endif 39813481Sgiacomo.travaglini@arm.com// In order to avoid having to include <windows.h>, use forward declaration 39913481Sgiacomo.travaglini@arm.com// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION. 40013481Sgiacomo.travaglini@arm.com// This assumption is verified by 40113481Sgiacomo.travaglini@arm.com// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION. 40213481Sgiacomo.travaglini@arm.comstruct _RTL_CRITICAL_SECTION; 40313481Sgiacomo.travaglini@arm.com#else 40413481Sgiacomo.travaglini@arm.com// This assumes that non-Windows OSes provide unistd.h. For OSes where this 40513481Sgiacomo.travaglini@arm.com// is not the case, we need to include headers that provide the functions 40613481Sgiacomo.travaglini@arm.com// mentioned above. 40713481Sgiacomo.travaglini@arm.com# include <unistd.h> 40813481Sgiacomo.travaglini@arm.com# include <strings.h> 40913481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 41013481Sgiacomo.travaglini@arm.com 41113481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX_ANDROID 41213481Sgiacomo.travaglini@arm.com// Used to define __ANDROID_API__ matching the target NDK API level. 41313481Sgiacomo.travaglini@arm.com# include <android/api-level.h> // NOLINT 41413481Sgiacomo.travaglini@arm.com#endif 41513481Sgiacomo.travaglini@arm.com 41613481Sgiacomo.travaglini@arm.com// Defines this to true iff Google Test can use POSIX regular expressions. 41713481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_POSIX_RE 41813481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID 41913481Sgiacomo.travaglini@arm.com// On Android, <regex.h> is only available starting with Gingerbread. 42013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) 42113481Sgiacomo.travaglini@arm.com# else 42213481Sgiacomo.travaglini@arm.com# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) 42313481Sgiacomo.travaglini@arm.com# endif 42413481Sgiacomo.travaglini@arm.com#endif 42513481Sgiacomo.travaglini@arm.com 42613481Sgiacomo.travaglini@arm.com#if GTEST_USES_PCRE 42713481Sgiacomo.travaglini@arm.com// The appropriate headers have already been included. 42813481Sgiacomo.travaglini@arm.com 42913481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_POSIX_RE 43013481Sgiacomo.travaglini@arm.com 43113481Sgiacomo.travaglini@arm.com// On some platforms, <regex.h> needs someone to define size_t, and 43213481Sgiacomo.travaglini@arm.com// won't compile otherwise. We can #include it here as we already 43313481Sgiacomo.travaglini@arm.com// included <stdlib.h>, which is guaranteed to define size_t through 43413481Sgiacomo.travaglini@arm.com// <stddef.h>. 43513481Sgiacomo.travaglini@arm.com# include <regex.h> // NOLINT 43613481Sgiacomo.travaglini@arm.com 43713481Sgiacomo.travaglini@arm.com# define GTEST_USES_POSIX_RE 1 43813481Sgiacomo.travaglini@arm.com 43913481Sgiacomo.travaglini@arm.com#elif GTEST_OS_WINDOWS 44013481Sgiacomo.travaglini@arm.com 44113481Sgiacomo.travaglini@arm.com// <regex.h> is not available on Windows. Use our own simple regex 44213481Sgiacomo.travaglini@arm.com// implementation instead. 44313481Sgiacomo.travaglini@arm.com# define GTEST_USES_SIMPLE_RE 1 44413481Sgiacomo.travaglini@arm.com 44513481Sgiacomo.travaglini@arm.com#else 44613481Sgiacomo.travaglini@arm.com 44713481Sgiacomo.travaglini@arm.com// <regex.h> may not be available on this platform. Use our own 44813481Sgiacomo.travaglini@arm.com// simple regex implementation instead. 44913481Sgiacomo.travaglini@arm.com# define GTEST_USES_SIMPLE_RE 1 45013481Sgiacomo.travaglini@arm.com 45113481Sgiacomo.travaglini@arm.com#endif // GTEST_USES_PCRE 45213481Sgiacomo.travaglini@arm.com 45313481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_EXCEPTIONS 45413481Sgiacomo.travaglini@arm.com// The user didn't tell us whether exceptions are enabled, so we need 45513481Sgiacomo.travaglini@arm.com// to figure it out. 45613481Sgiacomo.travaglini@arm.com# if defined(_MSC_VER) || defined(__BORLANDC__) 45713481Sgiacomo.travaglini@arm.com// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 45813481Sgiacomo.travaglini@arm.com// macro to enable exceptions, so we'll do the same. 45913481Sgiacomo.travaglini@arm.com// Assumes that exceptions are enabled by default. 46013481Sgiacomo.travaglini@arm.com# ifndef _HAS_EXCEPTIONS 46113481Sgiacomo.travaglini@arm.com# define _HAS_EXCEPTIONS 1 46213481Sgiacomo.travaglini@arm.com# endif // _HAS_EXCEPTIONS 46313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 46413481Sgiacomo.travaglini@arm.com# elif defined(__clang__) 46513481Sgiacomo.travaglini@arm.com// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714, 46613481Sgiacomo.travaglini@arm.com// but iff cleanups are enabled after that. In Obj-C++ files, there can be 46713481Sgiacomo.travaglini@arm.com// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions 46813481Sgiacomo.travaglini@arm.com// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++ 46913481Sgiacomo.travaglini@arm.com// exceptions starting at clang r206352, but which checked for cleanups prior to 47013481Sgiacomo.travaglini@arm.com// that. To reliably check for C++ exception availability with clang, check for 47113481Sgiacomo.travaglini@arm.com// __EXCEPTIONS && __has_feature(cxx_exceptions). 47213481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions)) 47313481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && __EXCEPTIONS 47413481Sgiacomo.travaglini@arm.com// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. 47513481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS 1 47613481Sgiacomo.travaglini@arm.com# elif defined(__SUNPRO_CC) 47713481Sgiacomo.travaglini@arm.com// Sun Pro CC supports exceptions. However, there is no compile-time way of 47813481Sgiacomo.travaglini@arm.com// detecting whether they are enabled or not. Therefore, we assume that 47913481Sgiacomo.travaglini@arm.com// they are enabled unless the user tells us otherwise. 48013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS 1 48113481Sgiacomo.travaglini@arm.com# elif defined(__IBMCPP__) && __EXCEPTIONS 48213481Sgiacomo.travaglini@arm.com// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. 48313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS 1 48413481Sgiacomo.travaglini@arm.com# elif defined(__HP_aCC) 48513481Sgiacomo.travaglini@arm.com// Exception handling is in effect by default in HP aCC compiler. It has to 48613481Sgiacomo.travaglini@arm.com// be turned of by +noeh compiler option if desired. 48713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS 1 48813481Sgiacomo.travaglini@arm.com# else 48913481Sgiacomo.travaglini@arm.com// For other compilers, we assume exceptions are disabled to be 49013481Sgiacomo.travaglini@arm.com// conservative. 49113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_EXCEPTIONS 0 49213481Sgiacomo.travaglini@arm.com# endif // defined(_MSC_VER) || defined(__BORLANDC__) 49313481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_EXCEPTIONS 49413481Sgiacomo.travaglini@arm.com 49513481Sgiacomo.travaglini@arm.com#if !defined(GTEST_HAS_STD_STRING) 49613481Sgiacomo.travaglini@arm.com// Even though we don't use this macro any longer, we keep it in case 49713481Sgiacomo.travaglini@arm.com// some clients still depend on it. 49813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_STRING 1 49913481Sgiacomo.travaglini@arm.com#elif !GTEST_HAS_STD_STRING 50013481Sgiacomo.travaglini@arm.com// The user told us that ::std::string isn't available. 50113481Sgiacomo.travaglini@arm.com# error "Google Test cannot be used where ::std::string isn't available." 50213481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_HAS_STD_STRING) 50313481Sgiacomo.travaglini@arm.com 50413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_GLOBAL_STRING 50513481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::string is available, so we need 50613481Sgiacomo.travaglini@arm.com// to figure it out. 50713481Sgiacomo.travaglini@arm.com 50813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GLOBAL_STRING 0 50913481Sgiacomo.travaglini@arm.com 51013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_STRING 51113481Sgiacomo.travaglini@arm.com 51213481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_STD_WSTRING 51313481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::std::wstring is available, so we need 51413481Sgiacomo.travaglini@arm.com// to figure it out. 51513481Sgiacomo.travaglini@arm.com// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 51613481Sgiacomo.travaglini@arm.com// is available. 51713481Sgiacomo.travaglini@arm.com 51813481Sgiacomo.travaglini@arm.com// Cygwin 1.7 and below doesn't support ::std::wstring. 51913481Sgiacomo.travaglini@arm.com// Solaris' libc++ doesn't support it either. Android has 52013481Sgiacomo.travaglini@arm.com// no support for it at least as recent as Froyo (2.2). 52113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_WSTRING \ 52213481Sgiacomo.travaglini@arm.com (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 52313481Sgiacomo.travaglini@arm.com 52413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_WSTRING 52513481Sgiacomo.travaglini@arm.com 52613481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_GLOBAL_WSTRING 52713481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::wstring is available, so we need 52813481Sgiacomo.travaglini@arm.com// to figure it out. 52913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GLOBAL_WSTRING \ 53013481Sgiacomo.travaglini@arm.com (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 53113481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_WSTRING 53213481Sgiacomo.travaglini@arm.com 53313481Sgiacomo.travaglini@arm.com// Determines whether RTTI is available. 53413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_RTTI 53513481Sgiacomo.travaglini@arm.com// The user didn't tell us whether RTTI is enabled, so we need to 53613481Sgiacomo.travaglini@arm.com// figure it out. 53713481Sgiacomo.travaglini@arm.com 53813481Sgiacomo.travaglini@arm.com# ifdef _MSC_VER 53913481Sgiacomo.travaglini@arm.com 54013481Sgiacomo.travaglini@arm.com# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 54113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 1 54213481Sgiacomo.travaglini@arm.com# else 54313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 0 54413481Sgiacomo.travaglini@arm.com# endif 54513481Sgiacomo.travaglini@arm.com 54613481Sgiacomo.travaglini@arm.com// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 54713481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 54813481Sgiacomo.travaglini@arm.com 54913481Sgiacomo.travaglini@arm.com# ifdef __GXX_RTTI 55013481Sgiacomo.travaglini@arm.com// When building against STLport with the Android NDK and with 55113481Sgiacomo.travaglini@arm.com// -frtti -fno-exceptions, the build fails at link time with undefined 55213481Sgiacomo.travaglini@arm.com// references to __cxa_bad_typeid. Note sure if STL or toolchain bug, 55313481Sgiacomo.travaglini@arm.com// so disable RTTI when detected. 55413481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ 55513481Sgiacomo.travaglini@arm.com !defined(__EXCEPTIONS) 55613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 0 55713481Sgiacomo.travaglini@arm.com# else 55813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 1 55913481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS 56013481Sgiacomo.travaglini@arm.com# else 56113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 0 56213481Sgiacomo.travaglini@arm.com# endif // __GXX_RTTI 56313481Sgiacomo.travaglini@arm.com 56413481Sgiacomo.travaglini@arm.com// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends 56513481Sgiacomo.travaglini@arm.com// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the 56613481Sgiacomo.travaglini@arm.com// first version with C++ support. 56713481Sgiacomo.travaglini@arm.com# elif defined(__clang__) 56813481Sgiacomo.travaglini@arm.com 56913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI __has_feature(cxx_rtti) 57013481Sgiacomo.travaglini@arm.com 57113481Sgiacomo.travaglini@arm.com// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if 57213481Sgiacomo.travaglini@arm.com// both the typeid and dynamic_cast features are present. 57313481Sgiacomo.travaglini@arm.com# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 57413481Sgiacomo.travaglini@arm.com 57513481Sgiacomo.travaglini@arm.com# ifdef __RTTI_ALL__ 57613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 1 57713481Sgiacomo.travaglini@arm.com# else 57813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 0 57913481Sgiacomo.travaglini@arm.com# endif 58013481Sgiacomo.travaglini@arm.com 58113481Sgiacomo.travaglini@arm.com# else 58213481Sgiacomo.travaglini@arm.com 58313481Sgiacomo.travaglini@arm.com// For all other compilers, we assume RTTI is enabled. 58413481Sgiacomo.travaglini@arm.com# define GTEST_HAS_RTTI 1 58513481Sgiacomo.travaglini@arm.com 58613481Sgiacomo.travaglini@arm.com# endif // _MSC_VER 58713481Sgiacomo.travaglini@arm.com 58813481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_RTTI 58913481Sgiacomo.travaglini@arm.com 59013481Sgiacomo.travaglini@arm.com// It's this header's responsibility to #include <typeinfo> when RTTI 59113481Sgiacomo.travaglini@arm.com// is enabled. 59213481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI 59313481Sgiacomo.travaglini@arm.com# include <typeinfo> 59413481Sgiacomo.travaglini@arm.com#endif 59513481Sgiacomo.travaglini@arm.com 59613481Sgiacomo.travaglini@arm.com// Determines whether Google Test can use the pthreads library. 59713481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_PTHREAD 59813481Sgiacomo.travaglini@arm.com// The user didn't tell us explicitly, so we make reasonable assumptions about 59913481Sgiacomo.travaglini@arm.com// which platforms have pthreads support. 60013481Sgiacomo.travaglini@arm.com// 60113481Sgiacomo.travaglini@arm.com// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 60213481Sgiacomo.travaglini@arm.com// to your compiler flags. 60313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \ 60413481Sgiacomo.travaglini@arm.com || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL) 60513481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PTHREAD 60613481Sgiacomo.travaglini@arm.com 60713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PTHREAD 60813481Sgiacomo.travaglini@arm.com// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is 60913481Sgiacomo.travaglini@arm.com// true. 61013481Sgiacomo.travaglini@arm.com# include <pthread.h> // NOLINT 61113481Sgiacomo.travaglini@arm.com 61213481Sgiacomo.travaglini@arm.com// For timespec and nanosleep, used below. 61313481Sgiacomo.travaglini@arm.com# include <time.h> // NOLINT 61413481Sgiacomo.travaglini@arm.com#endif 61513481Sgiacomo.travaglini@arm.com 61613481Sgiacomo.travaglini@arm.com// Determines if hash_map/hash_set are available. 61713481Sgiacomo.travaglini@arm.com// Only used for testing against those containers. 61813481Sgiacomo.travaglini@arm.com#if !defined(GTEST_HAS_HASH_MAP_) 61913481Sgiacomo.travaglini@arm.com# if _MSC_VER 62013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_HASH_MAP_ 1 // Indicates that hash_map is available. 62113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_HASH_SET_ 1 // Indicates that hash_set is available. 62213481Sgiacomo.travaglini@arm.com# endif // _MSC_VER 62313481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_HAS_HASH_MAP_) 62413481Sgiacomo.travaglini@arm.com 62513481Sgiacomo.travaglini@arm.com// Determines whether Google Test can use tr1/tuple. You can define 62613481Sgiacomo.travaglini@arm.com// this macro to 0 to prevent Google Test from using tuple (any 62713481Sgiacomo.travaglini@arm.com// feature depending on tuple with be disabled in this mode). 62813481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_TR1_TUPLE 62913481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) 63013481Sgiacomo.travaglini@arm.com// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>. 63113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TR1_TUPLE 0 63213481Sgiacomo.travaglini@arm.com# else 63313481Sgiacomo.travaglini@arm.com// The user didn't tell us not to do it, so we assume it's OK. 63413481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TR1_TUPLE 1 63513481Sgiacomo.travaglini@arm.com# endif 63613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_TR1_TUPLE 63713481Sgiacomo.travaglini@arm.com 63813481Sgiacomo.travaglini@arm.com// Determines whether Google Test's own tr1 tuple implementation 63913481Sgiacomo.travaglini@arm.com// should be used. 64013481Sgiacomo.travaglini@arm.com#ifndef GTEST_USE_OWN_TR1_TUPLE 64113481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out. 64213481Sgiacomo.travaglini@arm.com 64313481Sgiacomo.travaglini@arm.com// We use our own TR1 tuple if we aren't sure the user has an 64413481Sgiacomo.travaglini@arm.com// implementation of it already. At this time, libstdc++ 4.0.0+ and 64513481Sgiacomo.travaglini@arm.com// MSVC 2010 are the only mainstream standard libraries that come 64613481Sgiacomo.travaglini@arm.com// with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler 64713481Sgiacomo.travaglini@arm.com// pretends to be GCC by defining __GNUC__ and friends, but cannot 64813481Sgiacomo.travaglini@arm.com// compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1 64913481Sgiacomo.travaglini@arm.com// tuple in a 323 MB Feature Pack download, which we cannot assume the 65013481Sgiacomo.travaglini@arm.com// user has. QNX's QCC compiler is a modified GCC but it doesn't 65113481Sgiacomo.travaglini@arm.com// support TR1 tuple. libc++ only provides std::tuple, in C++11 mode, 65213481Sgiacomo.travaglini@arm.com// and it can be used with some compilers that define __GNUC__. 65313481Sgiacomo.travaglini@arm.com# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \ 65413481Sgiacomo.travaglini@arm.com && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600 65513481Sgiacomo.travaglini@arm.com# define GTEST_ENV_HAS_TR1_TUPLE_ 1 65613481Sgiacomo.travaglini@arm.com# endif 65713481Sgiacomo.travaglini@arm.com 65813481Sgiacomo.travaglini@arm.com// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used 65913481Sgiacomo.travaglini@arm.com// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6 66013481Sgiacomo.travaglini@arm.com// can build with clang but need to use gcc4.2's libstdc++). 66113481Sgiacomo.travaglini@arm.com# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325) 66213481Sgiacomo.travaglini@arm.com# define GTEST_ENV_HAS_STD_TUPLE_ 1 66313481Sgiacomo.travaglini@arm.com# endif 66413481Sgiacomo.travaglini@arm.com 66513481Sgiacomo.travaglini@arm.com# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_ 66613481Sgiacomo.travaglini@arm.com# define GTEST_USE_OWN_TR1_TUPLE 0 66713481Sgiacomo.travaglini@arm.com# else 66813481Sgiacomo.travaglini@arm.com# define GTEST_USE_OWN_TR1_TUPLE 1 66913481Sgiacomo.travaglini@arm.com# endif 67013481Sgiacomo.travaglini@arm.com 67113481Sgiacomo.travaglini@arm.com#endif // GTEST_USE_OWN_TR1_TUPLE 67213481Sgiacomo.travaglini@arm.com 67313481Sgiacomo.travaglini@arm.com// To avoid conditional compilation everywhere, we make it 67413481Sgiacomo.travaglini@arm.com// gtest-port.h's responsibility to #include the header implementing 67513481Sgiacomo.travaglini@arm.com// tuple. 67613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_TUPLE_ 67713481Sgiacomo.travaglini@arm.com# include <tuple> // IWYU pragma: export 67813481Sgiacomo.travaglini@arm.com# define GTEST_TUPLE_NAMESPACE_ ::std 67913481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_TUPLE_ 68013481Sgiacomo.travaglini@arm.com 68113481Sgiacomo.travaglini@arm.com// We include tr1::tuple even if std::tuple is available to define printers for 68213481Sgiacomo.travaglini@arm.com// them. 68313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_TR1_TUPLE 68413481Sgiacomo.travaglini@arm.com# ifndef GTEST_TUPLE_NAMESPACE_ 68513481Sgiacomo.travaglini@arm.com# define GTEST_TUPLE_NAMESPACE_ ::std::tr1 68613481Sgiacomo.travaglini@arm.com# endif // GTEST_TUPLE_NAMESPACE_ 68713481Sgiacomo.travaglini@arm.com 68813481Sgiacomo.travaglini@arm.com# if GTEST_USE_OWN_TR1_TUPLE 68913481Sgiacomo.travaglini@arm.com# include "gtest/internal/gtest-tuple.h" // IWYU pragma: export // NOLINT 69013481Sgiacomo.travaglini@arm.com# elif GTEST_ENV_HAS_STD_TUPLE_ 69113481Sgiacomo.travaglini@arm.com# include <tuple> 69213481Sgiacomo.travaglini@arm.com// C++11 puts its tuple into the ::std namespace rather than 69313481Sgiacomo.travaglini@arm.com// ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there. 69413481Sgiacomo.travaglini@arm.com// This causes undefined behavior, but supported compilers react in 69513481Sgiacomo.travaglini@arm.com// the way we intend. 69613481Sgiacomo.travaglini@arm.comnamespace std { 69713481Sgiacomo.travaglini@arm.comnamespace tr1 { 69813481Sgiacomo.travaglini@arm.comusing ::std::get; 69913481Sgiacomo.travaglini@arm.comusing ::std::make_tuple; 70013481Sgiacomo.travaglini@arm.comusing ::std::tuple; 70113481Sgiacomo.travaglini@arm.comusing ::std::tuple_element; 70213481Sgiacomo.travaglini@arm.comusing ::std::tuple_size; 70313481Sgiacomo.travaglini@arm.com} 70413481Sgiacomo.travaglini@arm.com} 70513481Sgiacomo.travaglini@arm.com 70613481Sgiacomo.travaglini@arm.com# elif GTEST_OS_SYMBIAN 70713481Sgiacomo.travaglini@arm.com 70813481Sgiacomo.travaglini@arm.com// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 70913481Sgiacomo.travaglini@arm.com// use STLport's tuple implementation, which unfortunately doesn't 71013481Sgiacomo.travaglini@arm.com// work as the copy of STLport distributed with Symbian is incomplete. 71113481Sgiacomo.travaglini@arm.com// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 71213481Sgiacomo.travaglini@arm.com// use its own tuple implementation. 71313481Sgiacomo.travaglini@arm.com# ifdef BOOST_HAS_TR1_TUPLE 71413481Sgiacomo.travaglini@arm.com# undef BOOST_HAS_TR1_TUPLE 71513481Sgiacomo.travaglini@arm.com# endif // BOOST_HAS_TR1_TUPLE 71613481Sgiacomo.travaglini@arm.com 71713481Sgiacomo.travaglini@arm.com// This prevents <boost/tr1/detail/config.hpp>, which defines 71813481Sgiacomo.travaglini@arm.com// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 71913481Sgiacomo.travaglini@arm.com# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 72013481Sgiacomo.travaglini@arm.com# include <tuple> // IWYU pragma: export // NOLINT 72113481Sgiacomo.travaglini@arm.com 72213481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 72313481Sgiacomo.travaglini@arm.com// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 72413481Sgiacomo.travaglini@arm.com// not conform to the TR1 spec, which requires the header to be <tuple>. 72513481Sgiacomo.travaglini@arm.com 72613481Sgiacomo.travaglini@arm.com# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 72713481Sgiacomo.travaglini@arm.com// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 72813481Sgiacomo.travaglini@arm.com// which is #included by <tr1/tuple>, to not compile when RTTI is 72913481Sgiacomo.travaglini@arm.com// disabled. _TR1_FUNCTIONAL is the header guard for 73013481Sgiacomo.travaglini@arm.com// <tr1/functional>. Hence the following #define is a hack to prevent 73113481Sgiacomo.travaglini@arm.com// <tr1/functional> from being included. 73213481Sgiacomo.travaglini@arm.com# define _TR1_FUNCTIONAL 1 73313481Sgiacomo.travaglini@arm.com# include <tr1/tuple> 73413481Sgiacomo.travaglini@arm.com# undef _TR1_FUNCTIONAL // Allows the user to #include 73513481Sgiacomo.travaglini@arm.com // <tr1/functional> if he chooses to. 73613481Sgiacomo.travaglini@arm.com# else 73713481Sgiacomo.travaglini@arm.com# include <tr1/tuple> // NOLINT 73813481Sgiacomo.travaglini@arm.com# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 73913481Sgiacomo.travaglini@arm.com 74013481Sgiacomo.travaglini@arm.com# else 74113481Sgiacomo.travaglini@arm.com// If the compiler is not GCC 4.0+, we assume the user is using a 74213481Sgiacomo.travaglini@arm.com// spec-conforming TR1 implementation. 74313481Sgiacomo.travaglini@arm.com# include <tuple> // IWYU pragma: export // NOLINT 74413481Sgiacomo.travaglini@arm.com# endif // GTEST_USE_OWN_TR1_TUPLE 74513481Sgiacomo.travaglini@arm.com 74613481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_TR1_TUPLE 74713481Sgiacomo.travaglini@arm.com 74813481Sgiacomo.travaglini@arm.com// Determines whether clone(2) is supported. 74913481Sgiacomo.travaglini@arm.com// Usually it will only be available on Linux, excluding 75013481Sgiacomo.travaglini@arm.com// Linux on the Itanium architecture. 75113481Sgiacomo.travaglini@arm.com// Also see http://linux.die.net/man/2/clone. 75213481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_CLONE 75313481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out. 75413481Sgiacomo.travaglini@arm.com 75513481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX && !defined(__ia64__) 75613481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID 75713481Sgiacomo.travaglini@arm.com// On Android, clone() is only available on ARM starting with Gingerbread. 75813481Sgiacomo.travaglini@arm.com# if defined(__arm__) && __ANDROID_API__ >= 9 75913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CLONE 1 76013481Sgiacomo.travaglini@arm.com# else 76113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CLONE 0 76213481Sgiacomo.travaglini@arm.com# endif 76313481Sgiacomo.travaglini@arm.com# else 76413481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CLONE 1 76513481Sgiacomo.travaglini@arm.com# endif 76613481Sgiacomo.travaglini@arm.com# else 76713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CLONE 0 76813481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_LINUX && !defined(__ia64__) 76913481Sgiacomo.travaglini@arm.com 77013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_CLONE 77113481Sgiacomo.travaglini@arm.com 77213481Sgiacomo.travaglini@arm.com// Determines whether to support stream redirection. This is used to test 77313481Sgiacomo.travaglini@arm.com// output correctness and to implement death tests. 77413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_STREAM_REDIRECTION 77513481Sgiacomo.travaglini@arm.com// By default, we assume that stream redirection is supported on all 77613481Sgiacomo.travaglini@arm.com// platforms except known mobile ones. 77713481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \ 77813481Sgiacomo.travaglini@arm.com GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT 77913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STREAM_REDIRECTION 0 78013481Sgiacomo.travaglini@arm.com# else 78113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STREAM_REDIRECTION 1 78213481Sgiacomo.travaglini@arm.com# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 78313481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STREAM_REDIRECTION 78413481Sgiacomo.travaglini@arm.com 78513481Sgiacomo.travaglini@arm.com// Determines whether to support death tests. 78613481Sgiacomo.travaglini@arm.com// Google Test does not support death tests for VC 7.1 and earlier as 78713481Sgiacomo.travaglini@arm.com// abort() in a VC 7.1 application compiled as GUI in debug config 78813481Sgiacomo.travaglini@arm.com// pops up a dialog window that cannot be suppressed programmatically. 78913481Sgiacomo.travaglini@arm.com#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 79013481Sgiacomo.travaglini@arm.com (GTEST_OS_MAC && !GTEST_OS_IOS) || \ 79113481Sgiacomo.travaglini@arm.com (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 79213481Sgiacomo.travaglini@arm.com GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \ 79313481Sgiacomo.travaglini@arm.com GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD) 79413481Sgiacomo.travaglini@arm.com# define GTEST_HAS_DEATH_TEST 1 79513481Sgiacomo.travaglini@arm.com#endif 79613481Sgiacomo.travaglini@arm.com 79713481Sgiacomo.travaglini@arm.com// We don't support MSVC 7.1 with exceptions disabled now. Therefore 79813481Sgiacomo.travaglini@arm.com// all the compilers we care about are adequate for supporting 79913481Sgiacomo.travaglini@arm.com// value-parameterized tests. 80013481Sgiacomo.travaglini@arm.com#define GTEST_HAS_PARAM_TEST 1 80113481Sgiacomo.travaglini@arm.com 80213481Sgiacomo.travaglini@arm.com// Determines whether to support type-driven tests. 80313481Sgiacomo.travaglini@arm.com 80413481Sgiacomo.travaglini@arm.com// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, 80513481Sgiacomo.travaglini@arm.com// Sun Pro CC, IBM Visual Age, and HP aCC support. 80613481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 80713481Sgiacomo.travaglini@arm.com defined(__IBMCPP__) || defined(__HP_aCC) 80813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TYPED_TEST 1 80913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TYPED_TEST_P 1 81013481Sgiacomo.travaglini@arm.com#endif 81113481Sgiacomo.travaglini@arm.com 81213481Sgiacomo.travaglini@arm.com// Determines whether to support Combine(). This only makes sense when 81313481Sgiacomo.travaglini@arm.com// value-parameterized tests are enabled. The implementation doesn't 81413481Sgiacomo.travaglini@arm.com// work on Sun Studio since it doesn't understand templated conversion 81513481Sgiacomo.travaglini@arm.com// operators. 81613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 81713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_COMBINE 1 81813481Sgiacomo.travaglini@arm.com#endif 81913481Sgiacomo.travaglini@arm.com 82013481Sgiacomo.travaglini@arm.com// Determines whether the system compiler uses UTF-16 for encoding wide strings. 82113481Sgiacomo.travaglini@arm.com#define GTEST_WIDE_STRING_USES_UTF16_ \ 82213481Sgiacomo.travaglini@arm.com (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 82313481Sgiacomo.travaglini@arm.com 82413481Sgiacomo.travaglini@arm.com// Determines whether test results can be streamed to a socket. 82513481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX 82613481Sgiacomo.travaglini@arm.com# define GTEST_CAN_STREAM_RESULTS_ 1 82713481Sgiacomo.travaglini@arm.com#endif 82813481Sgiacomo.travaglini@arm.com 82913481Sgiacomo.travaglini@arm.com// Defines some utility macros. 83013481Sgiacomo.travaglini@arm.com 83113481Sgiacomo.travaglini@arm.com// The GNU compiler emits a warning if nested "if" statements are followed by 83213481Sgiacomo.travaglini@arm.com// an "else" statement and braces are not used to explicitly disambiguate the 83313481Sgiacomo.travaglini@arm.com// "else" binding. This leads to problems with code like: 83413481Sgiacomo.travaglini@arm.com// 83513481Sgiacomo.travaglini@arm.com// if (gate) 83613481Sgiacomo.travaglini@arm.com// ASSERT_*(condition) << "Some message"; 83713481Sgiacomo.travaglini@arm.com// 83813481Sgiacomo.travaglini@arm.com// The "switch (0) case 0:" idiom is used to suppress this. 83913481Sgiacomo.travaglini@arm.com#ifdef __INTEL_COMPILER 84013481Sgiacomo.travaglini@arm.com# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 84113481Sgiacomo.travaglini@arm.com#else 84213481Sgiacomo.travaglini@arm.com# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT 84313481Sgiacomo.travaglini@arm.com#endif 84413481Sgiacomo.travaglini@arm.com 84513481Sgiacomo.travaglini@arm.com// Use this annotation at the end of a struct/class definition to 84613481Sgiacomo.travaglini@arm.com// prevent the compiler from optimizing away instances that are never 84713481Sgiacomo.travaglini@arm.com// used. This is useful when all interesting logic happens inside the 84813481Sgiacomo.travaglini@arm.com// c'tor and / or d'tor. Example: 84913481Sgiacomo.travaglini@arm.com// 85013481Sgiacomo.travaglini@arm.com// struct Foo { 85113481Sgiacomo.travaglini@arm.com// Foo() { ... } 85213481Sgiacomo.travaglini@arm.com// } GTEST_ATTRIBUTE_UNUSED_; 85313481Sgiacomo.travaglini@arm.com// 85413481Sgiacomo.travaglini@arm.com// Also use it after a variable or parameter declaration to tell the 85513481Sgiacomo.travaglini@arm.com// compiler the variable/parameter does not have to be used. 85613481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) && !defined(COMPILER_ICC) 85713481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 85813481Sgiacomo.travaglini@arm.com#elif defined(__clang__) 85913481Sgiacomo.travaglini@arm.com# if __has_attribute(unused) 86013481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 86113481Sgiacomo.travaglini@arm.com# endif 86213481Sgiacomo.travaglini@arm.com#endif 86313481Sgiacomo.travaglini@arm.com#ifndef GTEST_ATTRIBUTE_UNUSED_ 86413481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_UNUSED_ 86513481Sgiacomo.travaglini@arm.com#endif 86613481Sgiacomo.travaglini@arm.com 86713481Sgiacomo.travaglini@arm.com// A macro to disallow operator= 86813481Sgiacomo.travaglini@arm.com// This should be used in the private: declarations for a class. 86913481Sgiacomo.travaglini@arm.com#define GTEST_DISALLOW_ASSIGN_(type)\ 87013481Sgiacomo.travaglini@arm.com void operator=(type const &) 87113481Sgiacomo.travaglini@arm.com 87213481Sgiacomo.travaglini@arm.com// A macro to disallow copy constructor and operator= 87313481Sgiacomo.travaglini@arm.com// This should be used in the private: declarations for a class. 87413481Sgiacomo.travaglini@arm.com#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 87513481Sgiacomo.travaglini@arm.com type(type const &);\ 87613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(type) 87713481Sgiacomo.travaglini@arm.com 87813481Sgiacomo.travaglini@arm.com// Tell the compiler to warn about unused return values for functions declared 87913481Sgiacomo.travaglini@arm.com// with this macro. The macro should be used on function declarations 88013481Sgiacomo.travaglini@arm.com// following the argument list: 88113481Sgiacomo.travaglini@arm.com// 88213481Sgiacomo.travaglini@arm.com// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 88313481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 88413481Sgiacomo.travaglini@arm.com# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 88513481Sgiacomo.travaglini@arm.com#else 88613481Sgiacomo.travaglini@arm.com# define GTEST_MUST_USE_RESULT_ 88713481Sgiacomo.travaglini@arm.com#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 88813481Sgiacomo.travaglini@arm.com 88913481Sgiacomo.travaglini@arm.com// MS C++ compiler emits warning when a conditional expression is compile time 89013481Sgiacomo.travaglini@arm.com// constant. In some contexts this warning is false positive and needs to be 89113481Sgiacomo.travaglini@arm.com// suppressed. Use the following two macros in such cases: 89213481Sgiacomo.travaglini@arm.com// 89313481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_PUSH_() 89413481Sgiacomo.travaglini@arm.com// while (true) { 89513481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_POP_() 89613481Sgiacomo.travaglini@arm.com// } 89713481Sgiacomo.travaglini@arm.com# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \ 89813481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127) 89913481Sgiacomo.travaglini@arm.com# define GTEST_INTENTIONAL_CONST_COND_POP_() \ 90013481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 90113481Sgiacomo.travaglini@arm.com 90213481Sgiacomo.travaglini@arm.com// Determine whether the compiler supports Microsoft's Structured Exception 90313481Sgiacomo.travaglini@arm.com// Handling. This is supported by several Windows compilers but generally 90413481Sgiacomo.travaglini@arm.com// does not exist on any other system. 90513481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_SEH 90613481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out. 90713481Sgiacomo.travaglini@arm.com 90813481Sgiacomo.travaglini@arm.com# if defined(_MSC_VER) || defined(__BORLANDC__) 90913481Sgiacomo.travaglini@arm.com// These two compilers are known to support SEH. 91013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_SEH 1 91113481Sgiacomo.travaglini@arm.com# else 91213481Sgiacomo.travaglini@arm.com// Assume no SEH. 91313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_SEH 0 91413481Sgiacomo.travaglini@arm.com# endif 91513481Sgiacomo.travaglini@arm.com 91613481Sgiacomo.travaglini@arm.com#define GTEST_IS_THREADSAFE \ 91713481Sgiacomo.travaglini@arm.com (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \ 91813481Sgiacomo.travaglini@arm.com || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \ 91913481Sgiacomo.travaglini@arm.com || GTEST_HAS_PTHREAD) 92013481Sgiacomo.travaglini@arm.com 92113481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_SEH 92213481Sgiacomo.travaglini@arm.com 92313481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER 92413481Sgiacomo.travaglini@arm.com# if GTEST_LINKED_AS_SHARED_LIBRARY 92513481Sgiacomo.travaglini@arm.com# define GTEST_API_ __declspec(dllimport) 92613481Sgiacomo.travaglini@arm.com# elif GTEST_CREATE_SHARED_LIBRARY 92713481Sgiacomo.travaglini@arm.com# define GTEST_API_ __declspec(dllexport) 92813481Sgiacomo.travaglini@arm.com# endif 92913481Sgiacomo.travaglini@arm.com#elif __GNUC__ >= 4 || defined(__clang__) 93013481Sgiacomo.travaglini@arm.com# define GTEST_API_ __attribute__((visibility ("default"))) 93113481Sgiacomo.travaglini@arm.com#endif // _MSC_VER 93213481Sgiacomo.travaglini@arm.com 93313481Sgiacomo.travaglini@arm.com#ifndef GTEST_API_ 93413481Sgiacomo.travaglini@arm.com# define GTEST_API_ 93513481Sgiacomo.travaglini@arm.com#endif 93613481Sgiacomo.travaglini@arm.com 93713481Sgiacomo.travaglini@arm.com#ifdef __GNUC__ 93813481Sgiacomo.travaglini@arm.com// Ask the compiler to never inline a given function. 93913481Sgiacomo.travaglini@arm.com# define GTEST_NO_INLINE_ __attribute__((noinline)) 94013481Sgiacomo.travaglini@arm.com#else 94113481Sgiacomo.travaglini@arm.com# define GTEST_NO_INLINE_ 94213481Sgiacomo.travaglini@arm.com#endif 94313481Sgiacomo.travaglini@arm.com 94413481Sgiacomo.travaglini@arm.com// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. 94513481Sgiacomo.travaglini@arm.com#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION) 94613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CXXABI_H_ 1 94713481Sgiacomo.travaglini@arm.com#else 94813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CXXABI_H_ 0 94913481Sgiacomo.travaglini@arm.com#endif 95013481Sgiacomo.travaglini@arm.com 95113481Sgiacomo.travaglini@arm.com// A function level attribute to disable checking for use of uninitialized 95213481Sgiacomo.travaglini@arm.com// memory when built with MemorySanitizer. 95313481Sgiacomo.travaglini@arm.com#if defined(__clang__) 95413481Sgiacomo.travaglini@arm.com# if __has_feature(memory_sanitizer) 95513481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \ 95613481Sgiacomo.travaglini@arm.com __attribute__((no_sanitize_memory)) 95713481Sgiacomo.travaglini@arm.com# else 95813481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 95913481Sgiacomo.travaglini@arm.com# endif // __has_feature(memory_sanitizer) 96013481Sgiacomo.travaglini@arm.com#else 96113481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 96213481Sgiacomo.travaglini@arm.com#endif // __clang__ 96313481Sgiacomo.travaglini@arm.com 96413481Sgiacomo.travaglini@arm.com// A function level attribute to disable AddressSanitizer instrumentation. 96513481Sgiacomo.travaglini@arm.com#if defined(__clang__) 96613481Sgiacomo.travaglini@arm.com# if __has_feature(address_sanitizer) 96713481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \ 96813481Sgiacomo.travaglini@arm.com __attribute__((no_sanitize_address)) 96913481Sgiacomo.travaglini@arm.com# else 97013481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 97113481Sgiacomo.travaglini@arm.com# endif // __has_feature(address_sanitizer) 97213481Sgiacomo.travaglini@arm.com#else 97313481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 97413481Sgiacomo.travaglini@arm.com#endif // __clang__ 97513481Sgiacomo.travaglini@arm.com 97613481Sgiacomo.travaglini@arm.com// A function level attribute to disable ThreadSanitizer instrumentation. 97713481Sgiacomo.travaglini@arm.com#if defined(__clang__) 97813481Sgiacomo.travaglini@arm.com# if __has_feature(thread_sanitizer) 97913481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \ 98013481Sgiacomo.travaglini@arm.com __attribute__((no_sanitize_thread)) 98113481Sgiacomo.travaglini@arm.com# else 98213481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 98313481Sgiacomo.travaglini@arm.com# endif // __has_feature(thread_sanitizer) 98413481Sgiacomo.travaglini@arm.com#else 98513481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 98613481Sgiacomo.travaglini@arm.com#endif // __clang__ 98713481Sgiacomo.travaglini@arm.com 98813481Sgiacomo.travaglini@arm.comnamespace testing { 98913481Sgiacomo.travaglini@arm.com 99013481Sgiacomo.travaglini@arm.comclass Message; 99113481Sgiacomo.travaglini@arm.com 99213481Sgiacomo.travaglini@arm.com#if defined(GTEST_TUPLE_NAMESPACE_) 99313481Sgiacomo.travaglini@arm.com// Import tuple and friends into the ::testing namespace. 99413481Sgiacomo.travaglini@arm.com// It is part of our interface, having them in ::testing allows us to change 99513481Sgiacomo.travaglini@arm.com// their types as needed. 99613481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::get; 99713481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::make_tuple; 99813481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple; 99913481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple_size; 100013481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple_element; 100113481Sgiacomo.travaglini@arm.com#endif // defined(GTEST_TUPLE_NAMESPACE_) 100213481Sgiacomo.travaglini@arm.com 100313481Sgiacomo.travaglini@arm.comnamespace internal { 100413481Sgiacomo.travaglini@arm.com 100513481Sgiacomo.travaglini@arm.com// A secret type that Google Test users don't know about. It has no 100613481Sgiacomo.travaglini@arm.com// definition on purpose. Therefore it's impossible to create a 100713481Sgiacomo.travaglini@arm.com// Secret object, which is what we want. 100813481Sgiacomo.travaglini@arm.comclass Secret; 100913481Sgiacomo.travaglini@arm.com 101013481Sgiacomo.travaglini@arm.com// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time 101113481Sgiacomo.travaglini@arm.com// expression is true. For example, you could use it to verify the 101213481Sgiacomo.travaglini@arm.com// size of a static array: 101313481Sgiacomo.travaglini@arm.com// 101413481Sgiacomo.travaglini@arm.com// GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES, 101513481Sgiacomo.travaglini@arm.com// names_incorrect_size); 101613481Sgiacomo.travaglini@arm.com// 101713481Sgiacomo.travaglini@arm.com// or to make sure a struct is smaller than a certain size: 101813481Sgiacomo.travaglini@arm.com// 101913481Sgiacomo.travaglini@arm.com// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); 102013481Sgiacomo.travaglini@arm.com// 102113481Sgiacomo.travaglini@arm.com// The second argument to the macro is the name of the variable. If 102213481Sgiacomo.travaglini@arm.com// the expression is false, most compilers will issue a warning/error 102313481Sgiacomo.travaglini@arm.com// containing the name of the variable. 102413481Sgiacomo.travaglini@arm.com 102513481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 102613481Sgiacomo.travaglini@arm.com# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg) 102713481Sgiacomo.travaglini@arm.com#else // !GTEST_LANG_CXX11 102813481Sgiacomo.travaglini@arm.comtemplate <bool> 102913481Sgiacomo.travaglini@arm.com struct CompileAssert { 103013481Sgiacomo.travaglini@arm.com}; 103113481Sgiacomo.travaglini@arm.com 103213481Sgiacomo.travaglini@arm.com# define GTEST_COMPILE_ASSERT_(expr, msg) \ 103313481Sgiacomo.travaglini@arm.com typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \ 103413481Sgiacomo.travaglini@arm.com msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_ 103513481Sgiacomo.travaglini@arm.com#endif // !GTEST_LANG_CXX11 103613481Sgiacomo.travaglini@arm.com 103713481Sgiacomo.travaglini@arm.com// Implementation details of GTEST_COMPILE_ASSERT_: 103813481Sgiacomo.travaglini@arm.com// 103913481Sgiacomo.travaglini@arm.com// (In C++11, we simply use static_assert instead of the following) 104013481Sgiacomo.travaglini@arm.com// 104113481Sgiacomo.travaglini@arm.com// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 104213481Sgiacomo.travaglini@arm.com// elements (and thus is invalid) when the expression is false. 104313481Sgiacomo.travaglini@arm.com// 104413481Sgiacomo.travaglini@arm.com// - The simpler definition 104513481Sgiacomo.travaglini@arm.com// 104613481Sgiacomo.travaglini@arm.com// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] 104713481Sgiacomo.travaglini@arm.com// 104813481Sgiacomo.travaglini@arm.com// does not work, as gcc supports variable-length arrays whose sizes 104913481Sgiacomo.travaglini@arm.com// are determined at run-time (this is gcc's extension and not part 105013481Sgiacomo.travaglini@arm.com// of the C++ standard). As a result, gcc fails to reject the 105113481Sgiacomo.travaglini@arm.com// following code with the simple definition: 105213481Sgiacomo.travaglini@arm.com// 105313481Sgiacomo.travaglini@arm.com// int foo; 105413481Sgiacomo.travaglini@arm.com// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is 105513481Sgiacomo.travaglini@arm.com// // not a compile-time constant. 105613481Sgiacomo.travaglini@arm.com// 105713481Sgiacomo.travaglini@arm.com// - By using the type CompileAssert<(bool(expr))>, we ensures that 105813481Sgiacomo.travaglini@arm.com// expr is a compile-time constant. (Template arguments must be 105913481Sgiacomo.travaglini@arm.com// determined at compile-time.) 106013481Sgiacomo.travaglini@arm.com// 106113481Sgiacomo.travaglini@arm.com// - The outter parentheses in CompileAssert<(bool(expr))> are necessary 106213481Sgiacomo.travaglini@arm.com// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written 106313481Sgiacomo.travaglini@arm.com// 106413481Sgiacomo.travaglini@arm.com// CompileAssert<bool(expr)> 106513481Sgiacomo.travaglini@arm.com// 106613481Sgiacomo.travaglini@arm.com// instead, these compilers will refuse to compile 106713481Sgiacomo.travaglini@arm.com// 106813481Sgiacomo.travaglini@arm.com// GTEST_COMPILE_ASSERT_(5 > 0, some_message); 106913481Sgiacomo.travaglini@arm.com// 107013481Sgiacomo.travaglini@arm.com// (They seem to think the ">" in "5 > 0" marks the end of the 107113481Sgiacomo.travaglini@arm.com// template argument list.) 107213481Sgiacomo.travaglini@arm.com// 107313481Sgiacomo.travaglini@arm.com// - The array size is (bool(expr) ? 1 : -1), instead of simply 107413481Sgiacomo.travaglini@arm.com// 107513481Sgiacomo.travaglini@arm.com// ((expr) ? 1 : -1). 107613481Sgiacomo.travaglini@arm.com// 107713481Sgiacomo.travaglini@arm.com// This is to avoid running into a bug in MS VC 7.1, which 107813481Sgiacomo.travaglini@arm.com// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. 107913481Sgiacomo.travaglini@arm.com 108013481Sgiacomo.travaglini@arm.com// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. 108113481Sgiacomo.travaglini@arm.com// 108213481Sgiacomo.travaglini@arm.com// This template is declared, but intentionally undefined. 108313481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2> 108413481Sgiacomo.travaglini@arm.comstruct StaticAssertTypeEqHelper; 108513481Sgiacomo.travaglini@arm.com 108613481Sgiacomo.travaglini@arm.comtemplate <typename T> 108713481Sgiacomo.travaglini@arm.comstruct StaticAssertTypeEqHelper<T, T> { 108813481Sgiacomo.travaglini@arm.com enum { value = true }; 108913481Sgiacomo.travaglini@arm.com}; 109013481Sgiacomo.travaglini@arm.com 109113481Sgiacomo.travaglini@arm.com// Evaluates to the number of elements in 'array'. 109213481Sgiacomo.travaglini@arm.com#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0])) 109313481Sgiacomo.travaglini@arm.com 109413481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING 109513481Sgiacomo.travaglini@arm.comtypedef ::string string; 109613481Sgiacomo.travaglini@arm.com#else 109713481Sgiacomo.travaglini@arm.comtypedef ::std::string string; 109813481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_STRING 109913481Sgiacomo.travaglini@arm.com 110013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_WSTRING 110113481Sgiacomo.travaglini@arm.comtypedef ::wstring wstring; 110213481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_STD_WSTRING 110313481Sgiacomo.travaglini@arm.comtypedef ::std::wstring wstring; 110413481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_WSTRING 110513481Sgiacomo.travaglini@arm.com 110613481Sgiacomo.travaglini@arm.com// A helper for suppressing warnings on constant condition. It just 110713481Sgiacomo.travaglini@arm.com// returns 'condition'. 110813481Sgiacomo.travaglini@arm.comGTEST_API_ bool IsTrue(bool condition); 110913481Sgiacomo.travaglini@arm.com 111013481Sgiacomo.travaglini@arm.com// Defines scoped_ptr. 111113481Sgiacomo.travaglini@arm.com 111213481Sgiacomo.travaglini@arm.com// This implementation of scoped_ptr is PARTIAL - it only contains 111313481Sgiacomo.travaglini@arm.com// enough stuff to satisfy Google Test's need. 111413481Sgiacomo.travaglini@arm.comtemplate <typename T> 111513481Sgiacomo.travaglini@arm.comclass scoped_ptr { 111613481Sgiacomo.travaglini@arm.com public: 111713481Sgiacomo.travaglini@arm.com typedef T element_type; 111813481Sgiacomo.travaglini@arm.com 111913481Sgiacomo.travaglini@arm.com explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 112013481Sgiacomo.travaglini@arm.com ~scoped_ptr() { reset(); } 112113481Sgiacomo.travaglini@arm.com 112213481Sgiacomo.travaglini@arm.com T& operator*() const { return *ptr_; } 112313481Sgiacomo.travaglini@arm.com T* operator->() const { return ptr_; } 112413481Sgiacomo.travaglini@arm.com T* get() const { return ptr_; } 112513481Sgiacomo.travaglini@arm.com 112613481Sgiacomo.travaglini@arm.com T* release() { 112713481Sgiacomo.travaglini@arm.com T* const ptr = ptr_; 112813481Sgiacomo.travaglini@arm.com ptr_ = NULL; 112913481Sgiacomo.travaglini@arm.com return ptr; 113013481Sgiacomo.travaglini@arm.com } 113113481Sgiacomo.travaglini@arm.com 113213481Sgiacomo.travaglini@arm.com void reset(T* p = NULL) { 113313481Sgiacomo.travaglini@arm.com if (p != ptr_) { 113413481Sgiacomo.travaglini@arm.com if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 113513481Sgiacomo.travaglini@arm.com delete ptr_; 113613481Sgiacomo.travaglini@arm.com } 113713481Sgiacomo.travaglini@arm.com ptr_ = p; 113813481Sgiacomo.travaglini@arm.com } 113913481Sgiacomo.travaglini@arm.com } 114013481Sgiacomo.travaglini@arm.com 114113481Sgiacomo.travaglini@arm.com friend void swap(scoped_ptr& a, scoped_ptr& b) { 114213481Sgiacomo.travaglini@arm.com using std::swap; 114313481Sgiacomo.travaglini@arm.com swap(a.ptr_, b.ptr_); 114413481Sgiacomo.travaglini@arm.com } 114513481Sgiacomo.travaglini@arm.com 114613481Sgiacomo.travaglini@arm.com private: 114713481Sgiacomo.travaglini@arm.com T* ptr_; 114813481Sgiacomo.travaglini@arm.com 114913481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 115013481Sgiacomo.travaglini@arm.com}; 115113481Sgiacomo.travaglini@arm.com 115213481Sgiacomo.travaglini@arm.com// Defines RE. 115313481Sgiacomo.travaglini@arm.com 115413481Sgiacomo.travaglini@arm.com// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended 115513481Sgiacomo.travaglini@arm.com// Regular Expression syntax. 115613481Sgiacomo.travaglini@arm.comclass GTEST_API_ RE { 115713481Sgiacomo.travaglini@arm.com public: 115813481Sgiacomo.travaglini@arm.com // A copy constructor is required by the Standard to initialize object 115913481Sgiacomo.travaglini@arm.com // references from r-values. 116013481Sgiacomo.travaglini@arm.com RE(const RE& other) { Init(other.pattern()); } 116113481Sgiacomo.travaglini@arm.com 116213481Sgiacomo.travaglini@arm.com // Constructs an RE from a string. 116313481Sgiacomo.travaglini@arm.com RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 116413481Sgiacomo.travaglini@arm.com 116513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING 116613481Sgiacomo.travaglini@arm.com 116713481Sgiacomo.travaglini@arm.com RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 116813481Sgiacomo.travaglini@arm.com 116913481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_STRING 117013481Sgiacomo.travaglini@arm.com 117113481Sgiacomo.travaglini@arm.com RE(const char* regex) { Init(regex); } // NOLINT 117213481Sgiacomo.travaglini@arm.com ~RE(); 117313481Sgiacomo.travaglini@arm.com 117413481Sgiacomo.travaglini@arm.com // Returns the string representation of the regex. 117513481Sgiacomo.travaglini@arm.com const char* pattern() const { return pattern_; } 117613481Sgiacomo.travaglini@arm.com 117713481Sgiacomo.travaglini@arm.com // FullMatch(str, re) returns true iff regular expression re matches 117813481Sgiacomo.travaglini@arm.com // the entire str. 117913481Sgiacomo.travaglini@arm.com // PartialMatch(str, re) returns true iff regular expression re 118013481Sgiacomo.travaglini@arm.com // matches a substring of str (including str itself). 118113481Sgiacomo.travaglini@arm.com // 118213481Sgiacomo.travaglini@arm.com // TODO(wan@google.com): make FullMatch() and PartialMatch() work 118313481Sgiacomo.travaglini@arm.com // when str contains NUL characters. 118413481Sgiacomo.travaglini@arm.com static bool FullMatch(const ::std::string& str, const RE& re) { 118513481Sgiacomo.travaglini@arm.com return FullMatch(str.c_str(), re); 118613481Sgiacomo.travaglini@arm.com } 118713481Sgiacomo.travaglini@arm.com static bool PartialMatch(const ::std::string& str, const RE& re) { 118813481Sgiacomo.travaglini@arm.com return PartialMatch(str.c_str(), re); 118913481Sgiacomo.travaglini@arm.com } 119013481Sgiacomo.travaglini@arm.com 119113481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING 119213481Sgiacomo.travaglini@arm.com 119313481Sgiacomo.travaglini@arm.com static bool FullMatch(const ::string& str, const RE& re) { 119413481Sgiacomo.travaglini@arm.com return FullMatch(str.c_str(), re); 119513481Sgiacomo.travaglini@arm.com } 119613481Sgiacomo.travaglini@arm.com static bool PartialMatch(const ::string& str, const RE& re) { 119713481Sgiacomo.travaglini@arm.com return PartialMatch(str.c_str(), re); 119813481Sgiacomo.travaglini@arm.com } 119913481Sgiacomo.travaglini@arm.com 120013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_GLOBAL_STRING 120113481Sgiacomo.travaglini@arm.com 120213481Sgiacomo.travaglini@arm.com static bool FullMatch(const char* str, const RE& re); 120313481Sgiacomo.travaglini@arm.com static bool PartialMatch(const char* str, const RE& re); 120413481Sgiacomo.travaglini@arm.com 120513481Sgiacomo.travaglini@arm.com private: 120613481Sgiacomo.travaglini@arm.com void Init(const char* regex); 120713481Sgiacomo.travaglini@arm.com 120813481Sgiacomo.travaglini@arm.com // We use a const char* instead of an std::string, as Google Test used to be 120913481Sgiacomo.travaglini@arm.com // used where std::string is not available. TODO(wan@google.com): change to 121013481Sgiacomo.travaglini@arm.com // std::string. 121113481Sgiacomo.travaglini@arm.com const char* pattern_; 121213481Sgiacomo.travaglini@arm.com bool is_valid_; 121313481Sgiacomo.travaglini@arm.com 121413481Sgiacomo.travaglini@arm.com#if GTEST_USES_POSIX_RE 121513481Sgiacomo.travaglini@arm.com 121613481Sgiacomo.travaglini@arm.com regex_t full_regex_; // For FullMatch(). 121713481Sgiacomo.travaglini@arm.com regex_t partial_regex_; // For PartialMatch(). 121813481Sgiacomo.travaglini@arm.com 121913481Sgiacomo.travaglini@arm.com#else // GTEST_USES_SIMPLE_RE 122013481Sgiacomo.travaglini@arm.com 122113481Sgiacomo.travaglini@arm.com const char* full_pattern_; // For FullMatch(); 122213481Sgiacomo.travaglini@arm.com 122313481Sgiacomo.travaglini@arm.com#endif 122413481Sgiacomo.travaglini@arm.com 122513481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(RE); 122613481Sgiacomo.travaglini@arm.com}; 122713481Sgiacomo.travaglini@arm.com 122813481Sgiacomo.travaglini@arm.com// Formats a source file path and a line number as they would appear 122913481Sgiacomo.travaglini@arm.com// in an error message from the compiler used to compile this code. 123013481Sgiacomo.travaglini@arm.comGTEST_API_ ::std::string FormatFileLocation(const char* file, int line); 123113481Sgiacomo.travaglini@arm.com 123213481Sgiacomo.travaglini@arm.com// Formats a file location for compiler-independent XML output. 123313481Sgiacomo.travaglini@arm.com// Although this function is not platform dependent, we put it next to 123413481Sgiacomo.travaglini@arm.com// FormatFileLocation in order to contrast the two functions. 123513481Sgiacomo.travaglini@arm.comGTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, 123613481Sgiacomo.travaglini@arm.com int line); 123713481Sgiacomo.travaglini@arm.com 123813481Sgiacomo.travaglini@arm.com// Defines logging utilities: 123913481Sgiacomo.travaglini@arm.com// GTEST_LOG_(severity) - logs messages at the specified severity level. The 124013481Sgiacomo.travaglini@arm.com// message itself is streamed into the macro. 124113481Sgiacomo.travaglini@arm.com// LogToStderr() - directs all log messages to stderr. 124213481Sgiacomo.travaglini@arm.com// FlushInfoLog() - flushes informational log messages. 124313481Sgiacomo.travaglini@arm.com 124413481Sgiacomo.travaglini@arm.comenum GTestLogSeverity { 124513481Sgiacomo.travaglini@arm.com GTEST_INFO, 124613481Sgiacomo.travaglini@arm.com GTEST_WARNING, 124713481Sgiacomo.travaglini@arm.com GTEST_ERROR, 124813481Sgiacomo.travaglini@arm.com GTEST_FATAL 124913481Sgiacomo.travaglini@arm.com}; 125013481Sgiacomo.travaglini@arm.com 125113481Sgiacomo.travaglini@arm.com// Formats log entry severity, provides a stream object for streaming the 125213481Sgiacomo.travaglini@arm.com// log message, and terminates the message with a newline when going out of 125313481Sgiacomo.travaglini@arm.com// scope. 125413481Sgiacomo.travaglini@arm.comclass GTEST_API_ GTestLog { 125513481Sgiacomo.travaglini@arm.com public: 125613481Sgiacomo.travaglini@arm.com GTestLog(GTestLogSeverity severity, const char* file, int line); 125713481Sgiacomo.travaglini@arm.com 125813481Sgiacomo.travaglini@arm.com // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 125913481Sgiacomo.travaglini@arm.com ~GTestLog(); 126013481Sgiacomo.travaglini@arm.com 126113481Sgiacomo.travaglini@arm.com ::std::ostream& GetStream() { return ::std::cerr; } 126213481Sgiacomo.travaglini@arm.com 126313481Sgiacomo.travaglini@arm.com private: 126413481Sgiacomo.travaglini@arm.com const GTestLogSeverity severity_; 126513481Sgiacomo.travaglini@arm.com 126613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 126713481Sgiacomo.travaglini@arm.com}; 126813481Sgiacomo.travaglini@arm.com 126913481Sgiacomo.travaglini@arm.com#if !defined(GTEST_LOG_) 127013481Sgiacomo.travaglini@arm.com 127113481Sgiacomo.travaglini@arm.com# define GTEST_LOG_(severity) \ 127213481Sgiacomo.travaglini@arm.com ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 127313481Sgiacomo.travaglini@arm.com __FILE__, __LINE__).GetStream() 127413481Sgiacomo.travaglini@arm.com 127513481Sgiacomo.travaglini@arm.cominline void LogToStderr() {} 127613481Sgiacomo.travaglini@arm.cominline void FlushInfoLog() { fflush(NULL); } 127713481Sgiacomo.travaglini@arm.com 127813481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_LOG_) 127913481Sgiacomo.travaglini@arm.com 128013481Sgiacomo.travaglini@arm.com#if !defined(GTEST_CHECK_) 128113481Sgiacomo.travaglini@arm.com// INTERNAL IMPLEMENTATION - DO NOT USE. 128213481Sgiacomo.travaglini@arm.com// 128313481Sgiacomo.travaglini@arm.com// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 128413481Sgiacomo.travaglini@arm.com// is not satisfied. 128513481Sgiacomo.travaglini@arm.com// Synopsys: 128613481Sgiacomo.travaglini@arm.com// GTEST_CHECK_(boolean_condition); 128713481Sgiacomo.travaglini@arm.com// or 128813481Sgiacomo.travaglini@arm.com// GTEST_CHECK_(boolean_condition) << "Additional message"; 128913481Sgiacomo.travaglini@arm.com// 129013481Sgiacomo.travaglini@arm.com// This checks the condition and if the condition is not satisfied 129113481Sgiacomo.travaglini@arm.com// it prints message about the condition violation, including the 129213481Sgiacomo.travaglini@arm.com// condition itself, plus additional message streamed into it, if any, 129313481Sgiacomo.travaglini@arm.com// and then it aborts the program. It aborts the program irrespective of 129413481Sgiacomo.travaglini@arm.com// whether it is built in the debug mode or not. 129513481Sgiacomo.travaglini@arm.com# define GTEST_CHECK_(condition) \ 129613481Sgiacomo.travaglini@arm.com GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 129713481Sgiacomo.travaglini@arm.com if (::testing::internal::IsTrue(condition)) \ 129813481Sgiacomo.travaglini@arm.com ; \ 129913481Sgiacomo.travaglini@arm.com else \ 130013481Sgiacomo.travaglini@arm.com GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 130113481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_CHECK_) 130213481Sgiacomo.travaglini@arm.com 130313481Sgiacomo.travaglini@arm.com// An all-mode assert to verify that the given POSIX-style function 130413481Sgiacomo.travaglini@arm.com// call returns 0 (indicating success). Known limitation: this 130513481Sgiacomo.travaglini@arm.com// doesn't expand to a balanced 'if' statement, so enclose the macro 130613481Sgiacomo.travaglini@arm.com// in {} if you need to use it as the only statement in an 'if' 130713481Sgiacomo.travaglini@arm.com// branch. 130813481Sgiacomo.travaglini@arm.com#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 130913481Sgiacomo.travaglini@arm.com if (const int gtest_error = (posix_call)) \ 131013481Sgiacomo.travaglini@arm.com GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 131113481Sgiacomo.travaglini@arm.com << gtest_error 131213481Sgiacomo.travaglini@arm.com 131313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_MOVE_ 131413481Sgiacomo.travaglini@arm.comusing std::move; 131513481Sgiacomo.travaglini@arm.com#else // GTEST_HAS_STD_MOVE_ 131613481Sgiacomo.travaglini@arm.comtemplate <typename T> 131713481Sgiacomo.travaglini@arm.comconst T& move(const T& t) { 131813481Sgiacomo.travaglini@arm.com return t; 131913481Sgiacomo.travaglini@arm.com} 132013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STD_MOVE_ 132113481Sgiacomo.travaglini@arm.com 132213481Sgiacomo.travaglini@arm.com// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 132313481Sgiacomo.travaglini@arm.com// 132413481Sgiacomo.travaglini@arm.com// Use ImplicitCast_ as a safe version of static_cast for upcasting in 132513481Sgiacomo.travaglini@arm.com// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a 132613481Sgiacomo.travaglini@arm.com// const Foo*). When you use ImplicitCast_, the compiler checks that 132713481Sgiacomo.travaglini@arm.com// the cast is safe. Such explicit ImplicitCast_s are necessary in 132813481Sgiacomo.travaglini@arm.com// surprisingly many situations where C++ demands an exact type match 132913481Sgiacomo.travaglini@arm.com// instead of an argument type convertable to a target type. 133013481Sgiacomo.travaglini@arm.com// 133113481Sgiacomo.travaglini@arm.com// The syntax for using ImplicitCast_ is the same as for static_cast: 133213481Sgiacomo.travaglini@arm.com// 133313481Sgiacomo.travaglini@arm.com// ImplicitCast_<ToType>(expr) 133413481Sgiacomo.travaglini@arm.com// 133513481Sgiacomo.travaglini@arm.com// ImplicitCast_ would have been part of the C++ standard library, 133613481Sgiacomo.travaglini@arm.com// but the proposal was submitted too late. It will probably make 133713481Sgiacomo.travaglini@arm.com// its way into the language in the future. 133813481Sgiacomo.travaglini@arm.com// 133913481Sgiacomo.travaglini@arm.com// This relatively ugly name is intentional. It prevents clashes with 134013481Sgiacomo.travaglini@arm.com// similar functions users may have (e.g., implicit_cast). The internal 134113481Sgiacomo.travaglini@arm.com// namespace alone is not enough because the function can be found by ADL. 134213481Sgiacomo.travaglini@arm.comtemplate<typename To> 134313481Sgiacomo.travaglini@arm.cominline To ImplicitCast_(To x) { return x; } 134413481Sgiacomo.travaglini@arm.com 134513481Sgiacomo.travaglini@arm.com// When you upcast (that is, cast a pointer from type Foo to type 134613481Sgiacomo.travaglini@arm.com// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts 134713481Sgiacomo.travaglini@arm.com// always succeed. When you downcast (that is, cast a pointer from 134813481Sgiacomo.travaglini@arm.com// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 134913481Sgiacomo.travaglini@arm.com// how do you know the pointer is really of type SubclassOfFoo? It 135013481Sgiacomo.travaglini@arm.com// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 135113481Sgiacomo.travaglini@arm.com// when you downcast, you should use this macro. In debug mode, we 135213481Sgiacomo.travaglini@arm.com// use dynamic_cast<> to double-check the downcast is legal (we die 135313481Sgiacomo.travaglini@arm.com// if it's not). In normal mode, we do the efficient static_cast<> 135413481Sgiacomo.travaglini@arm.com// instead. Thus, it's important to test in debug mode to make sure 135513481Sgiacomo.travaglini@arm.com// the cast is legal! 135613481Sgiacomo.travaglini@arm.com// This is the only place in the code we should use dynamic_cast<>. 135713481Sgiacomo.travaglini@arm.com// In particular, you SHOULDN'T be using dynamic_cast<> in order to 135813481Sgiacomo.travaglini@arm.com// do RTTI (eg code like this: 135913481Sgiacomo.travaglini@arm.com// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); 136013481Sgiacomo.travaglini@arm.com// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); 136113481Sgiacomo.travaglini@arm.com// You should design the code some other way not to need this. 136213481Sgiacomo.travaglini@arm.com// 136313481Sgiacomo.travaglini@arm.com// This relatively ugly name is intentional. It prevents clashes with 136413481Sgiacomo.travaglini@arm.com// similar functions users may have (e.g., down_cast). The internal 136513481Sgiacomo.travaglini@arm.com// namespace alone is not enough because the function can be found by ADL. 136613481Sgiacomo.travaglini@arm.comtemplate<typename To, typename From> // use like this: DownCast_<T*>(foo); 136713481Sgiacomo.travaglini@arm.cominline To DownCast_(From* f) { // so we only accept pointers 136813481Sgiacomo.travaglini@arm.com // Ensures that To is a sub-type of From *. This test is here only 136913481Sgiacomo.travaglini@arm.com // for compile-time type checking, and has no overhead in an 137013481Sgiacomo.travaglini@arm.com // optimized build at run-time, as it will be optimized away 137113481Sgiacomo.travaglini@arm.com // completely. 137213481Sgiacomo.travaglini@arm.com GTEST_INTENTIONAL_CONST_COND_PUSH_() 137313481Sgiacomo.travaglini@arm.com if (false) { 137413481Sgiacomo.travaglini@arm.com GTEST_INTENTIONAL_CONST_COND_POP_() 137513481Sgiacomo.travaglini@arm.com const To to = NULL; 137613481Sgiacomo.travaglini@arm.com ::testing::internal::ImplicitCast_<From*>(to); 137713481Sgiacomo.travaglini@arm.com } 137813481Sgiacomo.travaglini@arm.com 137913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI 138013481Sgiacomo.travaglini@arm.com // RTTI: debug mode only! 138113481Sgiacomo.travaglini@arm.com GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL); 138213481Sgiacomo.travaglini@arm.com#endif 138313481Sgiacomo.travaglini@arm.com return static_cast<To>(f); 138413481Sgiacomo.travaglini@arm.com} 138513481Sgiacomo.travaglini@arm.com 138613481Sgiacomo.travaglini@arm.com// Downcasts the pointer of type Base to Derived. 138713481Sgiacomo.travaglini@arm.com// Derived must be a subclass of Base. The parameter MUST 138813481Sgiacomo.travaglini@arm.com// point to a class of type Derived, not any subclass of it. 138913481Sgiacomo.travaglini@arm.com// When RTTI is available, the function performs a runtime 139013481Sgiacomo.travaglini@arm.com// check to enforce this. 139113481Sgiacomo.travaglini@arm.comtemplate <class Derived, class Base> 139213481Sgiacomo.travaglini@arm.comDerived* CheckedDowncastToActualType(Base* base) { 139313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI 139413481Sgiacomo.travaglini@arm.com GTEST_CHECK_(typeid(*base) == typeid(Derived)); 139513481Sgiacomo.travaglini@arm.com#endif 139613481Sgiacomo.travaglini@arm.com 139713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DOWNCAST_ 139813481Sgiacomo.travaglini@arm.com return ::down_cast<Derived*>(base); 139913481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_RTTI 140013481Sgiacomo.travaglini@arm.com return dynamic_cast<Derived*>(base); // NOLINT 140113481Sgiacomo.travaglini@arm.com#else 140213481Sgiacomo.travaglini@arm.com return static_cast<Derived*>(base); // Poor man's downcast. 140313481Sgiacomo.travaglini@arm.com#endif 140413481Sgiacomo.travaglini@arm.com} 140513481Sgiacomo.travaglini@arm.com 140613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STREAM_REDIRECTION 140713481Sgiacomo.travaglini@arm.com 140813481Sgiacomo.travaglini@arm.com// Defines the stderr capturer: 140913481Sgiacomo.travaglini@arm.com// CaptureStdout - starts capturing stdout. 141013481Sgiacomo.travaglini@arm.com// GetCapturedStdout - stops capturing stdout and returns the captured string. 141113481Sgiacomo.travaglini@arm.com// CaptureStderr - starts capturing stderr. 141213481Sgiacomo.travaglini@arm.com// GetCapturedStderr - stops capturing stderr and returns the captured string. 141313481Sgiacomo.travaglini@arm.com// 141413481Sgiacomo.travaglini@arm.comGTEST_API_ void CaptureStdout(); 141513481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetCapturedStdout(); 141613481Sgiacomo.travaglini@arm.comGTEST_API_ void CaptureStderr(); 141713481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetCapturedStderr(); 141813481Sgiacomo.travaglini@arm.com 141913481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_STREAM_REDIRECTION 142013481Sgiacomo.travaglini@arm.com 142113481Sgiacomo.travaglini@arm.com// Returns a path to temporary directory. 142213481Sgiacomo.travaglini@arm.comGTEST_API_ std::string TempDir(); 142313481Sgiacomo.travaglini@arm.com 142413481Sgiacomo.travaglini@arm.com// Returns the size (in bytes) of a file. 142513481Sgiacomo.travaglini@arm.comGTEST_API_ size_t GetFileSize(FILE* file); 142613481Sgiacomo.travaglini@arm.com 142713481Sgiacomo.travaglini@arm.com// Reads the entire content of a file as a string. 142813481Sgiacomo.travaglini@arm.comGTEST_API_ std::string ReadEntireFile(FILE* file); 142913481Sgiacomo.travaglini@arm.com 143013481Sgiacomo.travaglini@arm.com// All command line arguments. 143113481Sgiacomo.travaglini@arm.comGTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs(); 143213481Sgiacomo.travaglini@arm.com 143313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 143413481Sgiacomo.travaglini@arm.com 143513481Sgiacomo.travaglini@arm.comconst ::std::vector<testing::internal::string>& GetInjectableArgvs(); 143613481Sgiacomo.travaglini@arm.comvoid SetInjectableArgvs(const ::std::vector<testing::internal::string>* 143713481Sgiacomo.travaglini@arm.com new_argvs); 143813481Sgiacomo.travaglini@arm.com 143913481Sgiacomo.travaglini@arm.com 144013481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_DEATH_TEST 144113481Sgiacomo.travaglini@arm.com 144213481Sgiacomo.travaglini@arm.com// Defines synchronization primitives. 144313481Sgiacomo.travaglini@arm.com#if GTEST_IS_THREADSAFE 144413481Sgiacomo.travaglini@arm.com# if GTEST_HAS_PTHREAD 144513481Sgiacomo.travaglini@arm.com// Sleeps for (roughly) n milliseconds. This function is only for testing 144613481Sgiacomo.travaglini@arm.com// Google Test's own constructs. Don't use it in user tests, either 144713481Sgiacomo.travaglini@arm.com// directly or indirectly. 144813481Sgiacomo.travaglini@arm.cominline void SleepMilliseconds(int n) { 144913481Sgiacomo.travaglini@arm.com const timespec time = { 145013481Sgiacomo.travaglini@arm.com 0, // 0 seconds. 145113481Sgiacomo.travaglini@arm.com n * 1000L * 1000L, // And n ms. 145213481Sgiacomo.travaglini@arm.com }; 145313481Sgiacomo.travaglini@arm.com nanosleep(&time, NULL); 145413481Sgiacomo.travaglini@arm.com} 145513481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_PTHREAD 145613481Sgiacomo.travaglini@arm.com 145713481Sgiacomo.travaglini@arm.com# if GTEST_HAS_NOTIFICATION_ 145813481Sgiacomo.travaglini@arm.com// Notification has already been imported into the namespace. 145913481Sgiacomo.travaglini@arm.com// Nothing to do here. 146013481Sgiacomo.travaglini@arm.com 146113481Sgiacomo.travaglini@arm.com# elif GTEST_HAS_PTHREAD 146213481Sgiacomo.travaglini@arm.com// Allows a controller thread to pause execution of newly created 146313481Sgiacomo.travaglini@arm.com// threads until notified. Instances of this class must be created 146413481Sgiacomo.travaglini@arm.com// and destroyed in the controller thread. 146513481Sgiacomo.travaglini@arm.com// 146613481Sgiacomo.travaglini@arm.com// This class is only for testing Google Test's own constructs. Do not 146713481Sgiacomo.travaglini@arm.com// use it in user tests, either directly or indirectly. 146813481Sgiacomo.travaglini@arm.comclass Notification { 146913481Sgiacomo.travaglini@arm.com public: 147013481Sgiacomo.travaglini@arm.com Notification() : notified_(false) { 147113481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 147213481Sgiacomo.travaglini@arm.com } 147313481Sgiacomo.travaglini@arm.com ~Notification() { 147413481Sgiacomo.travaglini@arm.com pthread_mutex_destroy(&mutex_); 147513481Sgiacomo.travaglini@arm.com } 147613481Sgiacomo.travaglini@arm.com 147713481Sgiacomo.travaglini@arm.com // Notifies all threads created with this notification to start. Must 147813481Sgiacomo.travaglini@arm.com // be called from the controller thread. 147913481Sgiacomo.travaglini@arm.com void Notify() { 148013481Sgiacomo.travaglini@arm.com pthread_mutex_lock(&mutex_); 148113481Sgiacomo.travaglini@arm.com notified_ = true; 148213481Sgiacomo.travaglini@arm.com pthread_mutex_unlock(&mutex_); 148313481Sgiacomo.travaglini@arm.com } 148413481Sgiacomo.travaglini@arm.com 148513481Sgiacomo.travaglini@arm.com // Blocks until the controller thread notifies. Must be called from a test 148613481Sgiacomo.travaglini@arm.com // thread. 148713481Sgiacomo.travaglini@arm.com void WaitForNotification() { 148813481Sgiacomo.travaglini@arm.com for (;;) { 148913481Sgiacomo.travaglini@arm.com pthread_mutex_lock(&mutex_); 149013481Sgiacomo.travaglini@arm.com const bool notified = notified_; 149113481Sgiacomo.travaglini@arm.com pthread_mutex_unlock(&mutex_); 149213481Sgiacomo.travaglini@arm.com if (notified) 149313481Sgiacomo.travaglini@arm.com break; 149413481Sgiacomo.travaglini@arm.com SleepMilliseconds(10); 149513481Sgiacomo.travaglini@arm.com } 149613481Sgiacomo.travaglini@arm.com } 149713481Sgiacomo.travaglini@arm.com 149813481Sgiacomo.travaglini@arm.com private: 149913481Sgiacomo.travaglini@arm.com pthread_mutex_t mutex_; 150013481Sgiacomo.travaglini@arm.com bool notified_; 150113481Sgiacomo.travaglini@arm.com 150213481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 150313481Sgiacomo.travaglini@arm.com}; 150413481Sgiacomo.travaglini@arm.com 150513481Sgiacomo.travaglini@arm.com# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 150613481Sgiacomo.travaglini@arm.com 150713481Sgiacomo.travaglini@arm.comGTEST_API_ void SleepMilliseconds(int n); 150813481Sgiacomo.travaglini@arm.com 150913481Sgiacomo.travaglini@arm.com// Provides leak-safe Windows kernel handle ownership. 151013481Sgiacomo.travaglini@arm.com// Used in death tests and in threading support. 151113481Sgiacomo.travaglini@arm.comclass GTEST_API_ AutoHandle { 151213481Sgiacomo.travaglini@arm.com public: 151313481Sgiacomo.travaglini@arm.com // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to 151413481Sgiacomo.travaglini@arm.com // avoid including <windows.h> in this header file. Including <windows.h> is 151513481Sgiacomo.travaglini@arm.com // undesirable because it defines a lot of symbols and macros that tend to 151613481Sgiacomo.travaglini@arm.com // conflict with client code. This assumption is verified by 151713481Sgiacomo.travaglini@arm.com // WindowsTypesTest.HANDLEIsVoidStar. 151813481Sgiacomo.travaglini@arm.com typedef void* Handle; 151913481Sgiacomo.travaglini@arm.com AutoHandle(); 152013481Sgiacomo.travaglini@arm.com explicit AutoHandle(Handle handle); 152113481Sgiacomo.travaglini@arm.com 152213481Sgiacomo.travaglini@arm.com ~AutoHandle(); 152313481Sgiacomo.travaglini@arm.com 152413481Sgiacomo.travaglini@arm.com Handle Get() const; 152513481Sgiacomo.travaglini@arm.com void Reset(); 152613481Sgiacomo.travaglini@arm.com void Reset(Handle handle); 152713481Sgiacomo.travaglini@arm.com 152813481Sgiacomo.travaglini@arm.com private: 152913481Sgiacomo.travaglini@arm.com // Returns true iff the handle is a valid handle object that can be closed. 153013481Sgiacomo.travaglini@arm.com bool IsCloseable() const; 153113481Sgiacomo.travaglini@arm.com 153213481Sgiacomo.travaglini@arm.com Handle handle_; 153313481Sgiacomo.travaglini@arm.com 153413481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); 153513481Sgiacomo.travaglini@arm.com}; 153613481Sgiacomo.travaglini@arm.com 153713481Sgiacomo.travaglini@arm.com// Allows a controller thread to pause execution of newly created 153813481Sgiacomo.travaglini@arm.com// threads until notified. Instances of this class must be created 153913481Sgiacomo.travaglini@arm.com// and destroyed in the controller thread. 154013481Sgiacomo.travaglini@arm.com// 154113481Sgiacomo.travaglini@arm.com// This class is only for testing Google Test's own constructs. Do not 154213481Sgiacomo.travaglini@arm.com// use it in user tests, either directly or indirectly. 154313481Sgiacomo.travaglini@arm.comclass GTEST_API_ Notification { 154413481Sgiacomo.travaglini@arm.com public: 154513481Sgiacomo.travaglini@arm.com Notification(); 154613481Sgiacomo.travaglini@arm.com void Notify(); 154713481Sgiacomo.travaglini@arm.com void WaitForNotification(); 154813481Sgiacomo.travaglini@arm.com 154913481Sgiacomo.travaglini@arm.com private: 155013481Sgiacomo.travaglini@arm.com AutoHandle event_; 155113481Sgiacomo.travaglini@arm.com 155213481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); 155313481Sgiacomo.travaglini@arm.com}; 155413481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_NOTIFICATION_ 155513481Sgiacomo.travaglini@arm.com 155613481Sgiacomo.travaglini@arm.com// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD 155713481Sgiacomo.travaglini@arm.com// defined, but we don't want to use MinGW's pthreads implementation, which 155813481Sgiacomo.travaglini@arm.com// has conformance problems with some versions of the POSIX standard. 155913481Sgiacomo.travaglini@arm.com# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW 156013481Sgiacomo.travaglini@arm.com 156113481Sgiacomo.travaglini@arm.com// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. 156213481Sgiacomo.travaglini@arm.com// Consequently, it cannot select a correct instantiation of ThreadWithParam 156313481Sgiacomo.travaglini@arm.com// in order to call its Run(). Introducing ThreadWithParamBase as a 156413481Sgiacomo.travaglini@arm.com// non-templated base class for ThreadWithParam allows us to bypass this 156513481Sgiacomo.travaglini@arm.com// problem. 156613481Sgiacomo.travaglini@arm.comclass ThreadWithParamBase { 156713481Sgiacomo.travaglini@arm.com public: 156813481Sgiacomo.travaglini@arm.com virtual ~ThreadWithParamBase() {} 156913481Sgiacomo.travaglini@arm.com virtual void Run() = 0; 157013481Sgiacomo.travaglini@arm.com}; 157113481Sgiacomo.travaglini@arm.com 157213481Sgiacomo.travaglini@arm.com// pthread_create() accepts a pointer to a function type with the C linkage. 157313481Sgiacomo.travaglini@arm.com// According to the Standard (7.5/1), function types with different linkages 157413481Sgiacomo.travaglini@arm.com// are different even if they are otherwise identical. Some compilers (for 157513481Sgiacomo.travaglini@arm.com// example, SunStudio) treat them as different types. Since class methods 157613481Sgiacomo.travaglini@arm.com// cannot be defined with C-linkage we need to define a free C-function to 157713481Sgiacomo.travaglini@arm.com// pass into pthread_create(). 157813481Sgiacomo.travaglini@arm.comextern "C" inline void* ThreadFuncWithCLinkage(void* thread) { 157913481Sgiacomo.travaglini@arm.com static_cast<ThreadWithParamBase*>(thread)->Run(); 158013481Sgiacomo.travaglini@arm.com return NULL; 158113481Sgiacomo.travaglini@arm.com} 158213481Sgiacomo.travaglini@arm.com 158313481Sgiacomo.travaglini@arm.com// Helper class for testing Google Test's multi-threading constructs. 158413481Sgiacomo.travaglini@arm.com// To use it, write: 158513481Sgiacomo.travaglini@arm.com// 158613481Sgiacomo.travaglini@arm.com// void ThreadFunc(int param) { /* Do things with param */ } 158713481Sgiacomo.travaglini@arm.com// Notification thread_can_start; 158813481Sgiacomo.travaglini@arm.com// ... 158913481Sgiacomo.travaglini@arm.com// // The thread_can_start parameter is optional; you can supply NULL. 159013481Sgiacomo.travaglini@arm.com// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); 159113481Sgiacomo.travaglini@arm.com// thread_can_start.Notify(); 159213481Sgiacomo.travaglini@arm.com// 159313481Sgiacomo.travaglini@arm.com// These classes are only for testing Google Test's own constructs. Do 159413481Sgiacomo.travaglini@arm.com// not use them in user tests, either directly or indirectly. 159513481Sgiacomo.travaglini@arm.comtemplate <typename T> 159613481Sgiacomo.travaglini@arm.comclass ThreadWithParam : public ThreadWithParamBase { 159713481Sgiacomo.travaglini@arm.com public: 159813481Sgiacomo.travaglini@arm.com typedef void UserThreadFunc(T); 159913481Sgiacomo.travaglini@arm.com 160013481Sgiacomo.travaglini@arm.com ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) 160113481Sgiacomo.travaglini@arm.com : func_(func), 160213481Sgiacomo.travaglini@arm.com param_(param), 160313481Sgiacomo.travaglini@arm.com thread_can_start_(thread_can_start), 160413481Sgiacomo.travaglini@arm.com finished_(false) { 160513481Sgiacomo.travaglini@arm.com ThreadWithParamBase* const base = this; 160613481Sgiacomo.travaglini@arm.com // The thread can be created only after all fields except thread_ 160713481Sgiacomo.travaglini@arm.com // have been initialized. 160813481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_( 160913481Sgiacomo.travaglini@arm.com pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); 161013481Sgiacomo.travaglini@arm.com } 161113481Sgiacomo.travaglini@arm.com ~ThreadWithParam() { Join(); } 161213481Sgiacomo.travaglini@arm.com 161313481Sgiacomo.travaglini@arm.com void Join() { 161413481Sgiacomo.travaglini@arm.com if (!finished_) { 161513481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); 161613481Sgiacomo.travaglini@arm.com finished_ = true; 161713481Sgiacomo.travaglini@arm.com } 161813481Sgiacomo.travaglini@arm.com } 161913481Sgiacomo.travaglini@arm.com 162013481Sgiacomo.travaglini@arm.com virtual void Run() { 162113481Sgiacomo.travaglini@arm.com if (thread_can_start_ != NULL) 162213481Sgiacomo.travaglini@arm.com thread_can_start_->WaitForNotification(); 162313481Sgiacomo.travaglini@arm.com func_(param_); 162413481Sgiacomo.travaglini@arm.com } 162513481Sgiacomo.travaglini@arm.com 162613481Sgiacomo.travaglini@arm.com private: 162713481Sgiacomo.travaglini@arm.com UserThreadFunc* const func_; // User-supplied thread function. 162813481Sgiacomo.travaglini@arm.com const T param_; // User-supplied parameter to the thread function. 162913481Sgiacomo.travaglini@arm.com // When non-NULL, used to block execution until the controller thread 163013481Sgiacomo.travaglini@arm.com // notifies. 163113481Sgiacomo.travaglini@arm.com Notification* const thread_can_start_; 163213481Sgiacomo.travaglini@arm.com bool finished_; // true iff we know that the thread function has finished. 163313481Sgiacomo.travaglini@arm.com pthread_t thread_; // The native thread object. 163413481Sgiacomo.travaglini@arm.com 163513481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 163613481Sgiacomo.travaglini@arm.com}; 163713481Sgiacomo.travaglini@arm.com# endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD || 163813481Sgiacomo.travaglini@arm.com // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 163913481Sgiacomo.travaglini@arm.com 164013481Sgiacomo.travaglini@arm.com# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 164113481Sgiacomo.travaglini@arm.com// Mutex and ThreadLocal have already been imported into the namespace. 164213481Sgiacomo.travaglini@arm.com// Nothing to do here. 164313481Sgiacomo.travaglini@arm.com 164413481Sgiacomo.travaglini@arm.com# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 164513481Sgiacomo.travaglini@arm.com 164613481Sgiacomo.travaglini@arm.com// Mutex implements mutex on Windows platforms. It is used in conjunction 164713481Sgiacomo.travaglini@arm.com// with class MutexLock: 164813481Sgiacomo.travaglini@arm.com// 164913481Sgiacomo.travaglini@arm.com// Mutex mutex; 165013481Sgiacomo.travaglini@arm.com// ... 165113481Sgiacomo.travaglini@arm.com// MutexLock lock(&mutex); // Acquires the mutex and releases it at the 165213481Sgiacomo.travaglini@arm.com// // end of the current scope. 165313481Sgiacomo.travaglini@arm.com// 165413481Sgiacomo.travaglini@arm.com// A static Mutex *must* be defined or declared using one of the following 165513481Sgiacomo.travaglini@arm.com// macros: 165613481Sgiacomo.travaglini@arm.com// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); 165713481Sgiacomo.travaglini@arm.com// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); 165813481Sgiacomo.travaglini@arm.com// 165913481Sgiacomo.travaglini@arm.com// (A non-static Mutex is defined/declared in the usual way). 166013481Sgiacomo.travaglini@arm.comclass GTEST_API_ Mutex { 166113481Sgiacomo.travaglini@arm.com public: 166213481Sgiacomo.travaglini@arm.com enum MutexType { kStatic = 0, kDynamic = 1 }; 166313481Sgiacomo.travaglini@arm.com // We rely on kStaticMutex being 0 as it is to what the linker initializes 166413481Sgiacomo.travaglini@arm.com // type_ in static mutexes. critical_section_ will be initialized lazily 166513481Sgiacomo.travaglini@arm.com // in ThreadSafeLazyInit(). 166613481Sgiacomo.travaglini@arm.com enum StaticConstructorSelector { kStaticMutex = 0 }; 166713481Sgiacomo.travaglini@arm.com 166813481Sgiacomo.travaglini@arm.com // This constructor intentionally does nothing. It relies on type_ being 166913481Sgiacomo.travaglini@arm.com // statically initialized to 0 (effectively setting it to kStatic) and on 167013481Sgiacomo.travaglini@arm.com // ThreadSafeLazyInit() to lazily initialize the rest of the members. 167113481Sgiacomo.travaglini@arm.com explicit Mutex(StaticConstructorSelector /*dummy*/) {} 167213481Sgiacomo.travaglini@arm.com 167313481Sgiacomo.travaglini@arm.com Mutex(); 167413481Sgiacomo.travaglini@arm.com ~Mutex(); 167513481Sgiacomo.travaglini@arm.com 167613481Sgiacomo.travaglini@arm.com void Lock(); 167713481Sgiacomo.travaglini@arm.com 167813481Sgiacomo.travaglini@arm.com void Unlock(); 167913481Sgiacomo.travaglini@arm.com 168013481Sgiacomo.travaglini@arm.com // Does nothing if the current thread holds the mutex. Otherwise, crashes 168113481Sgiacomo.travaglini@arm.com // with high probability. 168213481Sgiacomo.travaglini@arm.com void AssertHeld(); 168313481Sgiacomo.travaglini@arm.com 168413481Sgiacomo.travaglini@arm.com private: 168513481Sgiacomo.travaglini@arm.com // Initializes owner_thread_id_ and critical_section_ in static mutexes. 168613481Sgiacomo.travaglini@arm.com void ThreadSafeLazyInit(); 168713481Sgiacomo.travaglini@arm.com 168813481Sgiacomo.travaglini@arm.com // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx, 168913481Sgiacomo.travaglini@arm.com // we assume that 0 is an invalid value for thread IDs. 169013481Sgiacomo.travaglini@arm.com unsigned int owner_thread_id_; 169113481Sgiacomo.travaglini@arm.com 169213481Sgiacomo.travaglini@arm.com // For static mutexes, we rely on these members being initialized to zeros 169313481Sgiacomo.travaglini@arm.com // by the linker. 169413481Sgiacomo.travaglini@arm.com MutexType type_; 169513481Sgiacomo.travaglini@arm.com long critical_section_init_phase_; // NOLINT 169613481Sgiacomo.travaglini@arm.com _RTL_CRITICAL_SECTION* critical_section_; 169713481Sgiacomo.travaglini@arm.com 169813481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 169913481Sgiacomo.travaglini@arm.com}; 170013481Sgiacomo.travaglini@arm.com 170113481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 170213481Sgiacomo.travaglini@arm.com extern ::testing::internal::Mutex mutex 170313481Sgiacomo.travaglini@arm.com 170413481Sgiacomo.travaglini@arm.com# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 170513481Sgiacomo.travaglini@arm.com ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) 170613481Sgiacomo.travaglini@arm.com 170713481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would 170813481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some 170913481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against 171013481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than 171113481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)". Hence the typedef trick below. 171213481Sgiacomo.travaglini@arm.comclass GTestMutexLock { 171313481Sgiacomo.travaglini@arm.com public: 171413481Sgiacomo.travaglini@arm.com explicit GTestMutexLock(Mutex* mutex) 171513481Sgiacomo.travaglini@arm.com : mutex_(mutex) { mutex_->Lock(); } 171613481Sgiacomo.travaglini@arm.com 171713481Sgiacomo.travaglini@arm.com ~GTestMutexLock() { mutex_->Unlock(); } 171813481Sgiacomo.travaglini@arm.com 171913481Sgiacomo.travaglini@arm.com private: 172013481Sgiacomo.travaglini@arm.com Mutex* const mutex_; 172113481Sgiacomo.travaglini@arm.com 172213481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 172313481Sgiacomo.travaglini@arm.com}; 172413481Sgiacomo.travaglini@arm.com 172513481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock; 172613481Sgiacomo.travaglini@arm.com 172713481Sgiacomo.travaglini@arm.com// Base class for ValueHolder<T>. Allows a caller to hold and delete a value 172813481Sgiacomo.travaglini@arm.com// without knowing its type. 172913481Sgiacomo.travaglini@arm.comclass ThreadLocalValueHolderBase { 173013481Sgiacomo.travaglini@arm.com public: 173113481Sgiacomo.travaglini@arm.com virtual ~ThreadLocalValueHolderBase() {} 173213481Sgiacomo.travaglini@arm.com}; 173313481Sgiacomo.travaglini@arm.com 173413481Sgiacomo.travaglini@arm.com// Provides a way for a thread to send notifications to a ThreadLocal 173513481Sgiacomo.travaglini@arm.com// regardless of its parameter type. 173613481Sgiacomo.travaglini@arm.comclass ThreadLocalBase { 173713481Sgiacomo.travaglini@arm.com public: 173813481Sgiacomo.travaglini@arm.com // Creates a new ValueHolder<T> object holding a default value passed to 173913481Sgiacomo.travaglini@arm.com // this ThreadLocal<T>'s constructor and returns it. It is the caller's 174013481Sgiacomo.travaglini@arm.com // responsibility not to call this when the ThreadLocal<T> instance already 174113481Sgiacomo.travaglini@arm.com // has a value on the current thread. 174213481Sgiacomo.travaglini@arm.com virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0; 174313481Sgiacomo.travaglini@arm.com 174413481Sgiacomo.travaglini@arm.com protected: 174513481Sgiacomo.travaglini@arm.com ThreadLocalBase() {} 174613481Sgiacomo.travaglini@arm.com virtual ~ThreadLocalBase() {} 174713481Sgiacomo.travaglini@arm.com 174813481Sgiacomo.travaglini@arm.com private: 174913481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase); 175013481Sgiacomo.travaglini@arm.com}; 175113481Sgiacomo.travaglini@arm.com 175213481Sgiacomo.travaglini@arm.com// Maps a thread to a set of ThreadLocals that have values instantiated on that 175313481Sgiacomo.travaglini@arm.com// thread and notifies them when the thread exits. A ThreadLocal instance is 175413481Sgiacomo.travaglini@arm.com// expected to persist until all threads it has values on have terminated. 175513481Sgiacomo.travaglini@arm.comclass GTEST_API_ ThreadLocalRegistry { 175613481Sgiacomo.travaglini@arm.com public: 175713481Sgiacomo.travaglini@arm.com // Registers thread_local_instance as having value on the current thread. 175813481Sgiacomo.travaglini@arm.com // Returns a value that can be used to identify the thread from other threads. 175913481Sgiacomo.travaglini@arm.com static ThreadLocalValueHolderBase* GetValueOnCurrentThread( 176013481Sgiacomo.travaglini@arm.com const ThreadLocalBase* thread_local_instance); 176113481Sgiacomo.travaglini@arm.com 176213481Sgiacomo.travaglini@arm.com // Invoked when a ThreadLocal instance is destroyed. 176313481Sgiacomo.travaglini@arm.com static void OnThreadLocalDestroyed( 176413481Sgiacomo.travaglini@arm.com const ThreadLocalBase* thread_local_instance); 176513481Sgiacomo.travaglini@arm.com}; 176613481Sgiacomo.travaglini@arm.com 176713481Sgiacomo.travaglini@arm.comclass GTEST_API_ ThreadWithParamBase { 176813481Sgiacomo.travaglini@arm.com public: 176913481Sgiacomo.travaglini@arm.com void Join(); 177013481Sgiacomo.travaglini@arm.com 177113481Sgiacomo.travaglini@arm.com protected: 177213481Sgiacomo.travaglini@arm.com class Runnable { 177313481Sgiacomo.travaglini@arm.com public: 177413481Sgiacomo.travaglini@arm.com virtual ~Runnable() {} 177513481Sgiacomo.travaglini@arm.com virtual void Run() = 0; 177613481Sgiacomo.travaglini@arm.com }; 177713481Sgiacomo.travaglini@arm.com 177813481Sgiacomo.travaglini@arm.com ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start); 177913481Sgiacomo.travaglini@arm.com virtual ~ThreadWithParamBase(); 178013481Sgiacomo.travaglini@arm.com 178113481Sgiacomo.travaglini@arm.com private: 178213481Sgiacomo.travaglini@arm.com AutoHandle thread_; 178313481Sgiacomo.travaglini@arm.com}; 178413481Sgiacomo.travaglini@arm.com 178513481Sgiacomo.travaglini@arm.com// Helper class for testing Google Test's multi-threading constructs. 178613481Sgiacomo.travaglini@arm.comtemplate <typename T> 178713481Sgiacomo.travaglini@arm.comclass ThreadWithParam : public ThreadWithParamBase { 178813481Sgiacomo.travaglini@arm.com public: 178913481Sgiacomo.travaglini@arm.com typedef void UserThreadFunc(T); 179013481Sgiacomo.travaglini@arm.com 179113481Sgiacomo.travaglini@arm.com ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) 179213481Sgiacomo.travaglini@arm.com : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) { 179313481Sgiacomo.travaglini@arm.com } 179413481Sgiacomo.travaglini@arm.com virtual ~ThreadWithParam() {} 179513481Sgiacomo.travaglini@arm.com 179613481Sgiacomo.travaglini@arm.com private: 179713481Sgiacomo.travaglini@arm.com class RunnableImpl : public Runnable { 179813481Sgiacomo.travaglini@arm.com public: 179913481Sgiacomo.travaglini@arm.com RunnableImpl(UserThreadFunc* func, T param) 180013481Sgiacomo.travaglini@arm.com : func_(func), 180113481Sgiacomo.travaglini@arm.com param_(param) { 180213481Sgiacomo.travaglini@arm.com } 180313481Sgiacomo.travaglini@arm.com virtual ~RunnableImpl() {} 180413481Sgiacomo.travaglini@arm.com virtual void Run() { 180513481Sgiacomo.travaglini@arm.com func_(param_); 180613481Sgiacomo.travaglini@arm.com } 180713481Sgiacomo.travaglini@arm.com 180813481Sgiacomo.travaglini@arm.com private: 180913481Sgiacomo.travaglini@arm.com UserThreadFunc* const func_; 181013481Sgiacomo.travaglini@arm.com const T param_; 181113481Sgiacomo.travaglini@arm.com 181213481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl); 181313481Sgiacomo.travaglini@arm.com }; 181413481Sgiacomo.travaglini@arm.com 181513481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); 181613481Sgiacomo.travaglini@arm.com}; 181713481Sgiacomo.travaglini@arm.com 181813481Sgiacomo.travaglini@arm.com// Implements thread-local storage on Windows systems. 181913481Sgiacomo.travaglini@arm.com// 182013481Sgiacomo.travaglini@arm.com// // Thread 1 182113481Sgiacomo.travaglini@arm.com// ThreadLocal<int> tl(100); // 100 is the default value for each thread. 182213481Sgiacomo.travaglini@arm.com// 182313481Sgiacomo.travaglini@arm.com// // Thread 2 182413481Sgiacomo.travaglini@arm.com// tl.set(150); // Changes the value for thread 2 only. 182513481Sgiacomo.travaglini@arm.com// EXPECT_EQ(150, tl.get()); 182613481Sgiacomo.travaglini@arm.com// 182713481Sgiacomo.travaglini@arm.com// // Thread 1 182813481Sgiacomo.travaglini@arm.com// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. 182913481Sgiacomo.travaglini@arm.com// tl.set(200); 183013481Sgiacomo.travaglini@arm.com// EXPECT_EQ(200, tl.get()); 183113481Sgiacomo.travaglini@arm.com// 183213481Sgiacomo.travaglini@arm.com// The template type argument T must have a public copy constructor. 183313481Sgiacomo.travaglini@arm.com// In addition, the default ThreadLocal constructor requires T to have 183413481Sgiacomo.travaglini@arm.com// a public default constructor. 183513481Sgiacomo.travaglini@arm.com// 183613481Sgiacomo.travaglini@arm.com// The users of a TheadLocal instance have to make sure that all but one 183713481Sgiacomo.travaglini@arm.com// threads (including the main one) using that instance have exited before 183813481Sgiacomo.travaglini@arm.com// destroying it. Otherwise, the per-thread objects managed for them by the 183913481Sgiacomo.travaglini@arm.com// ThreadLocal instance are not guaranteed to be destroyed on all platforms. 184013481Sgiacomo.travaglini@arm.com// 184113481Sgiacomo.travaglini@arm.com// Google Test only uses global ThreadLocal objects. That means they 184213481Sgiacomo.travaglini@arm.com// will die after main() has returned. Therefore, no per-thread 184313481Sgiacomo.travaglini@arm.com// object managed by Google Test will be leaked as long as all threads 184413481Sgiacomo.travaglini@arm.com// using Google Test have exited when main() returns. 184513481Sgiacomo.travaglini@arm.comtemplate <typename T> 184613481Sgiacomo.travaglini@arm.comclass ThreadLocal : public ThreadLocalBase { 184713481Sgiacomo.travaglini@arm.com public: 184813481Sgiacomo.travaglini@arm.com ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {} 184913481Sgiacomo.travaglini@arm.com explicit ThreadLocal(const T& value) 185013481Sgiacomo.travaglini@arm.com : default_factory_(new InstanceValueHolderFactory(value)) {} 185113481Sgiacomo.travaglini@arm.com 185213481Sgiacomo.travaglini@arm.com ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); } 185313481Sgiacomo.travaglini@arm.com 185413481Sgiacomo.travaglini@arm.com T* pointer() { return GetOrCreateValue(); } 185513481Sgiacomo.travaglini@arm.com const T* pointer() const { return GetOrCreateValue(); } 185613481Sgiacomo.travaglini@arm.com const T& get() const { return *pointer(); } 185713481Sgiacomo.travaglini@arm.com void set(const T& value) { *pointer() = value; } 185813481Sgiacomo.travaglini@arm.com 185913481Sgiacomo.travaglini@arm.com private: 186013481Sgiacomo.travaglini@arm.com // Holds a value of T. Can be deleted via its base class without the caller 186113481Sgiacomo.travaglini@arm.com // knowing the type of T. 186213481Sgiacomo.travaglini@arm.com class ValueHolder : public ThreadLocalValueHolderBase { 186313481Sgiacomo.travaglini@arm.com public: 186413481Sgiacomo.travaglini@arm.com ValueHolder() : value_() {} 186513481Sgiacomo.travaglini@arm.com explicit ValueHolder(const T& value) : value_(value) {} 186613481Sgiacomo.travaglini@arm.com 186713481Sgiacomo.travaglini@arm.com T* pointer() { return &value_; } 186813481Sgiacomo.travaglini@arm.com 186913481Sgiacomo.travaglini@arm.com private: 187013481Sgiacomo.travaglini@arm.com T value_; 187113481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 187213481Sgiacomo.travaglini@arm.com }; 187313481Sgiacomo.travaglini@arm.com 187413481Sgiacomo.travaglini@arm.com 187513481Sgiacomo.travaglini@arm.com T* GetOrCreateValue() const { 187613481Sgiacomo.travaglini@arm.com return static_cast<ValueHolder*>( 187713481Sgiacomo.travaglini@arm.com ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer(); 187813481Sgiacomo.travaglini@arm.com } 187913481Sgiacomo.travaglini@arm.com 188013481Sgiacomo.travaglini@arm.com virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const { 188113481Sgiacomo.travaglini@arm.com return default_factory_->MakeNewHolder(); 188213481Sgiacomo.travaglini@arm.com } 188313481Sgiacomo.travaglini@arm.com 188413481Sgiacomo.travaglini@arm.com class ValueHolderFactory { 188513481Sgiacomo.travaglini@arm.com public: 188613481Sgiacomo.travaglini@arm.com ValueHolderFactory() {} 188713481Sgiacomo.travaglini@arm.com virtual ~ValueHolderFactory() {} 188813481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const = 0; 188913481Sgiacomo.travaglini@arm.com 189013481Sgiacomo.travaglini@arm.com private: 189113481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); 189213481Sgiacomo.travaglini@arm.com }; 189313481Sgiacomo.travaglini@arm.com 189413481Sgiacomo.travaglini@arm.com class DefaultValueHolderFactory : public ValueHolderFactory { 189513481Sgiacomo.travaglini@arm.com public: 189613481Sgiacomo.travaglini@arm.com DefaultValueHolderFactory() {} 189713481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); } 189813481Sgiacomo.travaglini@arm.com 189913481Sgiacomo.travaglini@arm.com private: 190013481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); 190113481Sgiacomo.travaglini@arm.com }; 190213481Sgiacomo.travaglini@arm.com 190313481Sgiacomo.travaglini@arm.com class InstanceValueHolderFactory : public ValueHolderFactory { 190413481Sgiacomo.travaglini@arm.com public: 190513481Sgiacomo.travaglini@arm.com explicit InstanceValueHolderFactory(const T& value) : value_(value) {} 190613481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const { 190713481Sgiacomo.travaglini@arm.com return new ValueHolder(value_); 190813481Sgiacomo.travaglini@arm.com } 190913481Sgiacomo.travaglini@arm.com 191013481Sgiacomo.travaglini@arm.com private: 191113481Sgiacomo.travaglini@arm.com const T value_; // The value for each thread. 191213481Sgiacomo.travaglini@arm.com 191313481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); 191413481Sgiacomo.travaglini@arm.com }; 191513481Sgiacomo.travaglini@arm.com 191613481Sgiacomo.travaglini@arm.com scoped_ptr<ValueHolderFactory> default_factory_; 191713481Sgiacomo.travaglini@arm.com 191813481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 191913481Sgiacomo.travaglini@arm.com}; 192013481Sgiacomo.travaglini@arm.com 192113481Sgiacomo.travaglini@arm.com# elif GTEST_HAS_PTHREAD 192213481Sgiacomo.travaglini@arm.com 192313481Sgiacomo.travaglini@arm.com// MutexBase and Mutex implement mutex on pthreads-based platforms. 192413481Sgiacomo.travaglini@arm.comclass MutexBase { 192513481Sgiacomo.travaglini@arm.com public: 192613481Sgiacomo.travaglini@arm.com // Acquires this mutex. 192713481Sgiacomo.travaglini@arm.com void Lock() { 192813481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); 192913481Sgiacomo.travaglini@arm.com owner_ = pthread_self(); 193013481Sgiacomo.travaglini@arm.com has_owner_ = true; 193113481Sgiacomo.travaglini@arm.com } 193213481Sgiacomo.travaglini@arm.com 193313481Sgiacomo.travaglini@arm.com // Releases this mutex. 193413481Sgiacomo.travaglini@arm.com void Unlock() { 193513481Sgiacomo.travaglini@arm.com // Since the lock is being released the owner_ field should no longer be 193613481Sgiacomo.travaglini@arm.com // considered valid. We don't protect writing to has_owner_ here, as it's 193713481Sgiacomo.travaglini@arm.com // the caller's responsibility to ensure that the current thread holds the 193813481Sgiacomo.travaglini@arm.com // mutex when this is called. 193913481Sgiacomo.travaglini@arm.com has_owner_ = false; 194013481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); 194113481Sgiacomo.travaglini@arm.com } 194213481Sgiacomo.travaglini@arm.com 194313481Sgiacomo.travaglini@arm.com // Does nothing if the current thread holds the mutex. Otherwise, crashes 194413481Sgiacomo.travaglini@arm.com // with high probability. 194513481Sgiacomo.travaglini@arm.com void AssertHeld() const { 194613481Sgiacomo.travaglini@arm.com GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self())) 194713481Sgiacomo.travaglini@arm.com << "The current thread is not holding the mutex @" << this; 194813481Sgiacomo.travaglini@arm.com } 194913481Sgiacomo.travaglini@arm.com 195013481Sgiacomo.travaglini@arm.com // A static mutex may be used before main() is entered. It may even 195113481Sgiacomo.travaglini@arm.com // be used before the dynamic initialization stage. Therefore we 195213481Sgiacomo.travaglini@arm.com // must be able to initialize a static mutex object at link time. 195313481Sgiacomo.travaglini@arm.com // This means MutexBase has to be a POD and its member variables 195413481Sgiacomo.travaglini@arm.com // have to be public. 195513481Sgiacomo.travaglini@arm.com public: 195613481Sgiacomo.travaglini@arm.com pthread_mutex_t mutex_; // The underlying pthread mutex. 195713481Sgiacomo.travaglini@arm.com // has_owner_ indicates whether the owner_ field below contains a valid thread 195813481Sgiacomo.travaglini@arm.com // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All 195913481Sgiacomo.travaglini@arm.com // accesses to the owner_ field should be protected by a check of this field. 196013481Sgiacomo.travaglini@arm.com // An alternative might be to memset() owner_ to all zeros, but there's no 196113481Sgiacomo.travaglini@arm.com // guarantee that a zero'd pthread_t is necessarily invalid or even different 196213481Sgiacomo.travaglini@arm.com // from pthread_self(). 196313481Sgiacomo.travaglini@arm.com bool has_owner_; 196413481Sgiacomo.travaglini@arm.com pthread_t owner_; // The thread holding the mutex. 196513481Sgiacomo.travaglini@arm.com}; 196613481Sgiacomo.travaglini@arm.com 196713481Sgiacomo.travaglini@arm.com// Forward-declares a static mutex. 196813481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 196913481Sgiacomo.travaglini@arm.com extern ::testing::internal::MutexBase mutex 197013481Sgiacomo.travaglini@arm.com 197113481Sgiacomo.travaglini@arm.com// Defines and statically (i.e. at link time) initializes a static mutex. 197213481Sgiacomo.travaglini@arm.com# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 197313481Sgiacomo.travaglini@arm.com ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() } 197413481Sgiacomo.travaglini@arm.com 197513481Sgiacomo.travaglini@arm.com// The Mutex class can only be used for mutexes created at runtime. It 197613481Sgiacomo.travaglini@arm.com// shares its API with MutexBase otherwise. 197713481Sgiacomo.travaglini@arm.comclass Mutex : public MutexBase { 197813481Sgiacomo.travaglini@arm.com public: 197913481Sgiacomo.travaglini@arm.com Mutex() { 198013481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); 198113481Sgiacomo.travaglini@arm.com has_owner_ = false; 198213481Sgiacomo.travaglini@arm.com } 198313481Sgiacomo.travaglini@arm.com ~Mutex() { 198413481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); 198513481Sgiacomo.travaglini@arm.com } 198613481Sgiacomo.travaglini@arm.com 198713481Sgiacomo.travaglini@arm.com private: 198813481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); 198913481Sgiacomo.travaglini@arm.com}; 199013481Sgiacomo.travaglini@arm.com 199113481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would 199213481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some 199313481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against 199413481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than 199513481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)". Hence the typedef trick below. 199613481Sgiacomo.travaglini@arm.comclass GTestMutexLock { 199713481Sgiacomo.travaglini@arm.com public: 199813481Sgiacomo.travaglini@arm.com explicit GTestMutexLock(MutexBase* mutex) 199913481Sgiacomo.travaglini@arm.com : mutex_(mutex) { mutex_->Lock(); } 200013481Sgiacomo.travaglini@arm.com 200113481Sgiacomo.travaglini@arm.com ~GTestMutexLock() { mutex_->Unlock(); } 200213481Sgiacomo.travaglini@arm.com 200313481Sgiacomo.travaglini@arm.com private: 200413481Sgiacomo.travaglini@arm.com MutexBase* const mutex_; 200513481Sgiacomo.travaglini@arm.com 200613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); 200713481Sgiacomo.travaglini@arm.com}; 200813481Sgiacomo.travaglini@arm.com 200913481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock; 201013481Sgiacomo.travaglini@arm.com 201113481Sgiacomo.travaglini@arm.com// Helpers for ThreadLocal. 201213481Sgiacomo.travaglini@arm.com 201313481Sgiacomo.travaglini@arm.com// pthread_key_create() requires DeleteThreadLocalValue() to have 201413481Sgiacomo.travaglini@arm.com// C-linkage. Therefore it cannot be templatized to access 201513481Sgiacomo.travaglini@arm.com// ThreadLocal<T>. Hence the need for class 201613481Sgiacomo.travaglini@arm.com// ThreadLocalValueHolderBase. 201713481Sgiacomo.travaglini@arm.comclass ThreadLocalValueHolderBase { 201813481Sgiacomo.travaglini@arm.com public: 201913481Sgiacomo.travaglini@arm.com virtual ~ThreadLocalValueHolderBase() {} 202013481Sgiacomo.travaglini@arm.com}; 202113481Sgiacomo.travaglini@arm.com 202213481Sgiacomo.travaglini@arm.com// Called by pthread to delete thread-local data stored by 202313481Sgiacomo.travaglini@arm.com// pthread_setspecific(). 202413481Sgiacomo.travaglini@arm.comextern "C" inline void DeleteThreadLocalValue(void* value_holder) { 202513481Sgiacomo.travaglini@arm.com delete static_cast<ThreadLocalValueHolderBase*>(value_holder); 202613481Sgiacomo.travaglini@arm.com} 202713481Sgiacomo.travaglini@arm.com 202813481Sgiacomo.travaglini@arm.com// Implements thread-local storage on pthreads-based systems. 202913481Sgiacomo.travaglini@arm.comtemplate <typename T> 203013481Sgiacomo.travaglini@arm.comclass ThreadLocal { 203113481Sgiacomo.travaglini@arm.com public: 203213481Sgiacomo.travaglini@arm.com ThreadLocal() 203313481Sgiacomo.travaglini@arm.com : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {} 203413481Sgiacomo.travaglini@arm.com explicit ThreadLocal(const T& value) 203513481Sgiacomo.travaglini@arm.com : key_(CreateKey()), 203613481Sgiacomo.travaglini@arm.com default_factory_(new InstanceValueHolderFactory(value)) {} 203713481Sgiacomo.travaglini@arm.com 203813481Sgiacomo.travaglini@arm.com ~ThreadLocal() { 203913481Sgiacomo.travaglini@arm.com // Destroys the managed object for the current thread, if any. 204013481Sgiacomo.travaglini@arm.com DeleteThreadLocalValue(pthread_getspecific(key_)); 204113481Sgiacomo.travaglini@arm.com 204213481Sgiacomo.travaglini@arm.com // Releases resources associated with the key. This will *not* 204313481Sgiacomo.travaglini@arm.com // delete managed objects for other threads. 204413481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); 204513481Sgiacomo.travaglini@arm.com } 204613481Sgiacomo.travaglini@arm.com 204713481Sgiacomo.travaglini@arm.com T* pointer() { return GetOrCreateValue(); } 204813481Sgiacomo.travaglini@arm.com const T* pointer() const { return GetOrCreateValue(); } 204913481Sgiacomo.travaglini@arm.com const T& get() const { return *pointer(); } 205013481Sgiacomo.travaglini@arm.com void set(const T& value) { *pointer() = value; } 205113481Sgiacomo.travaglini@arm.com 205213481Sgiacomo.travaglini@arm.com private: 205313481Sgiacomo.travaglini@arm.com // Holds a value of type T. 205413481Sgiacomo.travaglini@arm.com class ValueHolder : public ThreadLocalValueHolderBase { 205513481Sgiacomo.travaglini@arm.com public: 205613481Sgiacomo.travaglini@arm.com ValueHolder() : value_() {} 205713481Sgiacomo.travaglini@arm.com explicit ValueHolder(const T& value) : value_(value) {} 205813481Sgiacomo.travaglini@arm.com 205913481Sgiacomo.travaglini@arm.com T* pointer() { return &value_; } 206013481Sgiacomo.travaglini@arm.com 206113481Sgiacomo.travaglini@arm.com private: 206213481Sgiacomo.travaglini@arm.com T value_; 206313481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); 206413481Sgiacomo.travaglini@arm.com }; 206513481Sgiacomo.travaglini@arm.com 206613481Sgiacomo.travaglini@arm.com static pthread_key_t CreateKey() { 206713481Sgiacomo.travaglini@arm.com pthread_key_t key; 206813481Sgiacomo.travaglini@arm.com // When a thread exits, DeleteThreadLocalValue() will be called on 206913481Sgiacomo.travaglini@arm.com // the object managed for that thread. 207013481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_( 207113481Sgiacomo.travaglini@arm.com pthread_key_create(&key, &DeleteThreadLocalValue)); 207213481Sgiacomo.travaglini@arm.com return key; 207313481Sgiacomo.travaglini@arm.com } 207413481Sgiacomo.travaglini@arm.com 207513481Sgiacomo.travaglini@arm.com T* GetOrCreateValue() const { 207613481Sgiacomo.travaglini@arm.com ThreadLocalValueHolderBase* const holder = 207713481Sgiacomo.travaglini@arm.com static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); 207813481Sgiacomo.travaglini@arm.com if (holder != NULL) { 207913481Sgiacomo.travaglini@arm.com return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); 208013481Sgiacomo.travaglini@arm.com } 208113481Sgiacomo.travaglini@arm.com 208213481Sgiacomo.travaglini@arm.com ValueHolder* const new_holder = default_factory_->MakeNewHolder(); 208313481Sgiacomo.travaglini@arm.com ThreadLocalValueHolderBase* const holder_base = new_holder; 208413481Sgiacomo.travaglini@arm.com GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); 208513481Sgiacomo.travaglini@arm.com return new_holder->pointer(); 208613481Sgiacomo.travaglini@arm.com } 208713481Sgiacomo.travaglini@arm.com 208813481Sgiacomo.travaglini@arm.com class ValueHolderFactory { 208913481Sgiacomo.travaglini@arm.com public: 209013481Sgiacomo.travaglini@arm.com ValueHolderFactory() {} 209113481Sgiacomo.travaglini@arm.com virtual ~ValueHolderFactory() {} 209213481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const = 0; 209313481Sgiacomo.travaglini@arm.com 209413481Sgiacomo.travaglini@arm.com private: 209513481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); 209613481Sgiacomo.travaglini@arm.com }; 209713481Sgiacomo.travaglini@arm.com 209813481Sgiacomo.travaglini@arm.com class DefaultValueHolderFactory : public ValueHolderFactory { 209913481Sgiacomo.travaglini@arm.com public: 210013481Sgiacomo.travaglini@arm.com DefaultValueHolderFactory() {} 210113481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); } 210213481Sgiacomo.travaglini@arm.com 210313481Sgiacomo.travaglini@arm.com private: 210413481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); 210513481Sgiacomo.travaglini@arm.com }; 210613481Sgiacomo.travaglini@arm.com 210713481Sgiacomo.travaglini@arm.com class InstanceValueHolderFactory : public ValueHolderFactory { 210813481Sgiacomo.travaglini@arm.com public: 210913481Sgiacomo.travaglini@arm.com explicit InstanceValueHolderFactory(const T& value) : value_(value) {} 211013481Sgiacomo.travaglini@arm.com virtual ValueHolder* MakeNewHolder() const { 211113481Sgiacomo.travaglini@arm.com return new ValueHolder(value_); 211213481Sgiacomo.travaglini@arm.com } 211313481Sgiacomo.travaglini@arm.com 211413481Sgiacomo.travaglini@arm.com private: 211513481Sgiacomo.travaglini@arm.com const T value_; // The value for each thread. 211613481Sgiacomo.travaglini@arm.com 211713481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); 211813481Sgiacomo.travaglini@arm.com }; 211913481Sgiacomo.travaglini@arm.com 212013481Sgiacomo.travaglini@arm.com // A key pthreads uses for looking up per-thread values. 212113481Sgiacomo.travaglini@arm.com const pthread_key_t key_; 212213481Sgiacomo.travaglini@arm.com scoped_ptr<ValueHolderFactory> default_factory_; 212313481Sgiacomo.travaglini@arm.com 212413481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); 212513481Sgiacomo.travaglini@arm.com}; 212613481Sgiacomo.travaglini@arm.com 212713481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 212813481Sgiacomo.travaglini@arm.com 212913481Sgiacomo.travaglini@arm.com#else // GTEST_IS_THREADSAFE 213013481Sgiacomo.travaglini@arm.com 213113481Sgiacomo.travaglini@arm.com// A dummy implementation of synchronization primitives (mutex, lock, 213213481Sgiacomo.travaglini@arm.com// and thread-local variable). Necessary for compiling Google Test where 213313481Sgiacomo.travaglini@arm.com// mutex is not supported - using Google Test in multiple threads is not 213413481Sgiacomo.travaglini@arm.com// supported on such platforms. 213513481Sgiacomo.travaglini@arm.com 213613481Sgiacomo.travaglini@arm.comclass Mutex { 213713481Sgiacomo.travaglini@arm.com public: 213813481Sgiacomo.travaglini@arm.com Mutex() {} 213913481Sgiacomo.travaglini@arm.com void Lock() {} 214013481Sgiacomo.travaglini@arm.com void Unlock() {} 214113481Sgiacomo.travaglini@arm.com void AssertHeld() const {} 214213481Sgiacomo.travaglini@arm.com}; 214313481Sgiacomo.travaglini@arm.com 214413481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 214513481Sgiacomo.travaglini@arm.com extern ::testing::internal::Mutex mutex 214613481Sgiacomo.travaglini@arm.com 214713481Sgiacomo.travaglini@arm.com# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 214813481Sgiacomo.travaglini@arm.com 214913481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would 215013481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some 215113481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against 215213481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than 215313481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)". Hence the typedef trick below. 215413481Sgiacomo.travaglini@arm.comclass GTestMutexLock { 215513481Sgiacomo.travaglini@arm.com public: 215613481Sgiacomo.travaglini@arm.com explicit GTestMutexLock(Mutex*) {} // NOLINT 215713481Sgiacomo.travaglini@arm.com}; 215813481Sgiacomo.travaglini@arm.com 215913481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock; 216013481Sgiacomo.travaglini@arm.com 216113481Sgiacomo.travaglini@arm.comtemplate <typename T> 216213481Sgiacomo.travaglini@arm.comclass ThreadLocal { 216313481Sgiacomo.travaglini@arm.com public: 216413481Sgiacomo.travaglini@arm.com ThreadLocal() : value_() {} 216513481Sgiacomo.travaglini@arm.com explicit ThreadLocal(const T& value) : value_(value) {} 216613481Sgiacomo.travaglini@arm.com T* pointer() { return &value_; } 216713481Sgiacomo.travaglini@arm.com const T* pointer() const { return &value_; } 216813481Sgiacomo.travaglini@arm.com const T& get() const { return value_; } 216913481Sgiacomo.travaglini@arm.com void set(const T& value) { value_ = value; } 217013481Sgiacomo.travaglini@arm.com private: 217113481Sgiacomo.travaglini@arm.com T value_; 217213481Sgiacomo.travaglini@arm.com}; 217313481Sgiacomo.travaglini@arm.com 217413481Sgiacomo.travaglini@arm.com#endif // GTEST_IS_THREADSAFE 217513481Sgiacomo.travaglini@arm.com 217613481Sgiacomo.travaglini@arm.com// Returns the number of threads running in the process, or 0 to indicate that 217713481Sgiacomo.travaglini@arm.com// we cannot detect it. 217813481Sgiacomo.travaglini@arm.comGTEST_API_ size_t GetThreadCount(); 217913481Sgiacomo.travaglini@arm.com 218013481Sgiacomo.travaglini@arm.com// Passing non-POD classes through ellipsis (...) crashes the ARM 218113481Sgiacomo.travaglini@arm.com// compiler and generates a warning in Sun Studio. The Nokia Symbian 218213481Sgiacomo.travaglini@arm.com// and the IBM XL C/C++ compiler try to instantiate a copy constructor 218313481Sgiacomo.travaglini@arm.com// for objects passed through ellipsis (...), failing for uncopyable 218413481Sgiacomo.travaglini@arm.com// objects. We define this to ensure that only POD is passed through 218513481Sgiacomo.travaglini@arm.com// ellipsis on these systems. 218613481Sgiacomo.travaglini@arm.com#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 218713481Sgiacomo.travaglini@arm.com// We lose support for NULL detection where the compiler doesn't like 218813481Sgiacomo.travaglini@arm.com// passing non-POD classes through ellipsis (...). 218913481Sgiacomo.travaglini@arm.com# define GTEST_ELLIPSIS_NEEDS_POD_ 1 219013481Sgiacomo.travaglini@arm.com#else 219113481Sgiacomo.travaglini@arm.com# define GTEST_CAN_COMPARE_NULL 1 219213481Sgiacomo.travaglini@arm.com#endif 219313481Sgiacomo.travaglini@arm.com 219413481Sgiacomo.travaglini@arm.com// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 219513481Sgiacomo.travaglini@arm.com// const T& and const T* in a function template. These compilers 219613481Sgiacomo.travaglini@arm.com// _can_ decide between class template specializations for T and T*, 219713481Sgiacomo.travaglini@arm.com// so a tr1::type_traits-like is_pointer works. 219813481Sgiacomo.travaglini@arm.com#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 219913481Sgiacomo.travaglini@arm.com# define GTEST_NEEDS_IS_POINTER_ 1 220013481Sgiacomo.travaglini@arm.com#endif 220113481Sgiacomo.travaglini@arm.com 220213481Sgiacomo.travaglini@arm.comtemplate <bool bool_value> 220313481Sgiacomo.travaglini@arm.comstruct bool_constant { 220413481Sgiacomo.travaglini@arm.com typedef bool_constant<bool_value> type; 220513481Sgiacomo.travaglini@arm.com static const bool value = bool_value; 220613481Sgiacomo.travaglini@arm.com}; 220713481Sgiacomo.travaglini@arm.comtemplate <bool bool_value> const bool bool_constant<bool_value>::value; 220813481Sgiacomo.travaglini@arm.com 220913481Sgiacomo.travaglini@arm.comtypedef bool_constant<false> false_type; 221013481Sgiacomo.travaglini@arm.comtypedef bool_constant<true> true_type; 221113481Sgiacomo.travaglini@arm.com 221213481Sgiacomo.travaglini@arm.comtemplate <typename T> 221313481Sgiacomo.travaglini@arm.comstruct is_pointer : public false_type {}; 221413481Sgiacomo.travaglini@arm.com 221513481Sgiacomo.travaglini@arm.comtemplate <typename T> 221613481Sgiacomo.travaglini@arm.comstruct is_pointer<T*> : public true_type {}; 221713481Sgiacomo.travaglini@arm.com 221813481Sgiacomo.travaglini@arm.comtemplate <typename Iterator> 221913481Sgiacomo.travaglini@arm.comstruct IteratorTraits { 222013481Sgiacomo.travaglini@arm.com typedef typename Iterator::value_type value_type; 222113481Sgiacomo.travaglini@arm.com}; 222213481Sgiacomo.travaglini@arm.com 222313481Sgiacomo.travaglini@arm.comtemplate <typename T> 222413481Sgiacomo.travaglini@arm.comstruct IteratorTraits<T*> { 222513481Sgiacomo.travaglini@arm.com typedef T value_type; 222613481Sgiacomo.travaglini@arm.com}; 222713481Sgiacomo.travaglini@arm.com 222813481Sgiacomo.travaglini@arm.comtemplate <typename T> 222913481Sgiacomo.travaglini@arm.comstruct IteratorTraits<const T*> { 223013481Sgiacomo.travaglini@arm.com typedef T value_type; 223113481Sgiacomo.travaglini@arm.com}; 223213481Sgiacomo.travaglini@arm.com 223313481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 223413481Sgiacomo.travaglini@arm.com# define GTEST_PATH_SEP_ "\\" 223513481Sgiacomo.travaglini@arm.com# define GTEST_HAS_ALT_PATH_SEP_ 1 223613481Sgiacomo.travaglini@arm.com// The biggest signed integer type the compiler supports. 223713481Sgiacomo.travaglini@arm.comtypedef __int64 BiggestInt; 223813481Sgiacomo.travaglini@arm.com#else 223913481Sgiacomo.travaglini@arm.com# define GTEST_PATH_SEP_ "/" 224013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_ALT_PATH_SEP_ 0 224113481Sgiacomo.travaglini@arm.comtypedef long long BiggestInt; // NOLINT 224213481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 224313481Sgiacomo.travaglini@arm.com 224413481Sgiacomo.travaglini@arm.com// Utilities for char. 224513481Sgiacomo.travaglini@arm.com 224613481Sgiacomo.travaglini@arm.com// isspace(int ch) and friends accept an unsigned char or EOF. char 224713481Sgiacomo.travaglini@arm.com// may be signed, depending on the compiler (or compiler flags). 224813481Sgiacomo.travaglini@arm.com// Therefore we need to cast a char to unsigned char before calling 224913481Sgiacomo.travaglini@arm.com// isspace(), etc. 225013481Sgiacomo.travaglini@arm.com 225113481Sgiacomo.travaglini@arm.cominline bool IsAlpha(char ch) { 225213481Sgiacomo.travaglini@arm.com return isalpha(static_cast<unsigned char>(ch)) != 0; 225313481Sgiacomo.travaglini@arm.com} 225413481Sgiacomo.travaglini@arm.cominline bool IsAlNum(char ch) { 225513481Sgiacomo.travaglini@arm.com return isalnum(static_cast<unsigned char>(ch)) != 0; 225613481Sgiacomo.travaglini@arm.com} 225713481Sgiacomo.travaglini@arm.cominline bool IsDigit(char ch) { 225813481Sgiacomo.travaglini@arm.com return isdigit(static_cast<unsigned char>(ch)) != 0; 225913481Sgiacomo.travaglini@arm.com} 226013481Sgiacomo.travaglini@arm.cominline bool IsLower(char ch) { 226113481Sgiacomo.travaglini@arm.com return islower(static_cast<unsigned char>(ch)) != 0; 226213481Sgiacomo.travaglini@arm.com} 226313481Sgiacomo.travaglini@arm.cominline bool IsSpace(char ch) { 226413481Sgiacomo.travaglini@arm.com return isspace(static_cast<unsigned char>(ch)) != 0; 226513481Sgiacomo.travaglini@arm.com} 226613481Sgiacomo.travaglini@arm.cominline bool IsUpper(char ch) { 226713481Sgiacomo.travaglini@arm.com return isupper(static_cast<unsigned char>(ch)) != 0; 226813481Sgiacomo.travaglini@arm.com} 226913481Sgiacomo.travaglini@arm.cominline bool IsXDigit(char ch) { 227013481Sgiacomo.travaglini@arm.com return isxdigit(static_cast<unsigned char>(ch)) != 0; 227113481Sgiacomo.travaglini@arm.com} 227213481Sgiacomo.travaglini@arm.cominline bool IsXDigit(wchar_t ch) { 227313481Sgiacomo.travaglini@arm.com const unsigned char low_byte = static_cast<unsigned char>(ch); 227413481Sgiacomo.travaglini@arm.com return ch == low_byte && isxdigit(low_byte) != 0; 227513481Sgiacomo.travaglini@arm.com} 227613481Sgiacomo.travaglini@arm.com 227713481Sgiacomo.travaglini@arm.cominline char ToLower(char ch) { 227813481Sgiacomo.travaglini@arm.com return static_cast<char>(tolower(static_cast<unsigned char>(ch))); 227913481Sgiacomo.travaglini@arm.com} 228013481Sgiacomo.travaglini@arm.cominline char ToUpper(char ch) { 228113481Sgiacomo.travaglini@arm.com return static_cast<char>(toupper(static_cast<unsigned char>(ch))); 228213481Sgiacomo.travaglini@arm.com} 228313481Sgiacomo.travaglini@arm.com 228413481Sgiacomo.travaglini@arm.cominline std::string StripTrailingSpaces(std::string str) { 228513481Sgiacomo.travaglini@arm.com std::string::iterator it = str.end(); 228613481Sgiacomo.travaglini@arm.com while (it != str.begin() && IsSpace(*--it)) 228713481Sgiacomo.travaglini@arm.com it = str.erase(it); 228813481Sgiacomo.travaglini@arm.com return str; 228913481Sgiacomo.travaglini@arm.com} 229013481Sgiacomo.travaglini@arm.com 229113481Sgiacomo.travaglini@arm.com// The testing::internal::posix namespace holds wrappers for common 229213481Sgiacomo.travaglini@arm.com// POSIX functions. These wrappers hide the differences between 229313481Sgiacomo.travaglini@arm.com// Windows/MSVC and POSIX systems. Since some compilers define these 229413481Sgiacomo.travaglini@arm.com// standard functions as macros, the wrapper cannot have the same name 229513481Sgiacomo.travaglini@arm.com// as the wrapped function. 229613481Sgiacomo.travaglini@arm.com 229713481Sgiacomo.travaglini@arm.comnamespace posix { 229813481Sgiacomo.travaglini@arm.com 229913481Sgiacomo.travaglini@arm.com// Functions with a different name on Windows. 230013481Sgiacomo.travaglini@arm.com 230113481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 230213481Sgiacomo.travaglini@arm.com 230313481Sgiacomo.travaglini@arm.comtypedef struct _stat StatStruct; 230413481Sgiacomo.travaglini@arm.com 230513481Sgiacomo.travaglini@arm.com# ifdef __BORLANDC__ 230613481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return isatty(fd); } 230713481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) { 230813481Sgiacomo.travaglini@arm.com return stricmp(s1, s2); 230913481Sgiacomo.travaglini@arm.com} 231013481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return strdup(src); } 231113481Sgiacomo.travaglini@arm.com# else // !__BORLANDC__ 231213481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE 231313481Sgiacomo.travaglini@arm.cominline int IsATTY(int /* fd */) { return 0; } 231413481Sgiacomo.travaglini@arm.com# else 231513481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return _isatty(fd); } 231613481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS_MOBILE 231713481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) { 231813481Sgiacomo.travaglini@arm.com return _stricmp(s1, s2); 231913481Sgiacomo.travaglini@arm.com} 232013481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return _strdup(src); } 232113481Sgiacomo.travaglini@arm.com# endif // __BORLANDC__ 232213481Sgiacomo.travaglini@arm.com 232313481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE 232413481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 232513481Sgiacomo.travaglini@arm.com// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 232613481Sgiacomo.travaglini@arm.com// time and thus not defined there. 232713481Sgiacomo.travaglini@arm.com# else 232813481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return _fileno(file); } 232913481Sgiacomo.travaglini@arm.cominline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 233013481Sgiacomo.travaglini@arm.cominline int RmDir(const char* dir) { return _rmdir(dir); } 233113481Sgiacomo.travaglini@arm.cominline bool IsDir(const StatStruct& st) { 233213481Sgiacomo.travaglini@arm.com return (_S_IFDIR & st.st_mode) != 0; 233313481Sgiacomo.travaglini@arm.com} 233413481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS_MOBILE 233513481Sgiacomo.travaglini@arm.com 233613481Sgiacomo.travaglini@arm.com#else 233713481Sgiacomo.travaglini@arm.com 233813481Sgiacomo.travaglini@arm.comtypedef struct stat StatStruct; 233913481Sgiacomo.travaglini@arm.com 234013481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return fileno(file); } 234113481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return isatty(fd); } 234213481Sgiacomo.travaglini@arm.cominline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 234313481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) { 234413481Sgiacomo.travaglini@arm.com return strcasecmp(s1, s2); 234513481Sgiacomo.travaglini@arm.com} 234613481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return strdup(src); } 234713481Sgiacomo.travaglini@arm.cominline int RmDir(const char* dir) { return rmdir(dir); } 234813481Sgiacomo.travaglini@arm.cominline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 234913481Sgiacomo.travaglini@arm.com 235013481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 235113481Sgiacomo.travaglini@arm.com 235213481Sgiacomo.travaglini@arm.com// Functions deprecated by MSVC 8.0. 235313481Sgiacomo.travaglini@arm.com 235413481Sgiacomo.travaglini@arm.comGTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */) 235513481Sgiacomo.travaglini@arm.com 235613481Sgiacomo.travaglini@arm.cominline const char* StrNCpy(char* dest, const char* src, size_t n) { 235713481Sgiacomo.travaglini@arm.com return strncpy(dest, src, n); 235813481Sgiacomo.travaglini@arm.com} 235913481Sgiacomo.travaglini@arm.com 236013481Sgiacomo.travaglini@arm.com// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 236113481Sgiacomo.travaglini@arm.com// StrError() aren't needed on Windows CE at this time and thus not 236213481Sgiacomo.travaglini@arm.com// defined there. 236313481Sgiacomo.travaglini@arm.com 236413481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 236513481Sgiacomo.travaglini@arm.cominline int ChDir(const char* dir) { return chdir(dir); } 236613481Sgiacomo.travaglini@arm.com#endif 236713481Sgiacomo.travaglini@arm.cominline FILE* FOpen(const char* path, const char* mode) { 236813481Sgiacomo.travaglini@arm.com return fopen(path, mode); 236913481Sgiacomo.travaglini@arm.com} 237013481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE 237113481Sgiacomo.travaglini@arm.cominline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 237213481Sgiacomo.travaglini@arm.com return freopen(path, mode, stream); 237313481Sgiacomo.travaglini@arm.com} 237413481Sgiacomo.travaglini@arm.cominline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 237513481Sgiacomo.travaglini@arm.com#endif 237613481Sgiacomo.travaglini@arm.cominline int FClose(FILE* fp) { return fclose(fp); } 237713481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE 237813481Sgiacomo.travaglini@arm.cominline int Read(int fd, void* buf, unsigned int count) { 237913481Sgiacomo.travaglini@arm.com return static_cast<int>(read(fd, buf, count)); 238013481Sgiacomo.travaglini@arm.com} 238113481Sgiacomo.travaglini@arm.cominline int Write(int fd, const void* buf, unsigned int count) { 238213481Sgiacomo.travaglini@arm.com return static_cast<int>(write(fd, buf, count)); 238313481Sgiacomo.travaglini@arm.com} 238413481Sgiacomo.travaglini@arm.cominline int Close(int fd) { return close(fd); } 238513481Sgiacomo.travaglini@arm.cominline const char* StrError(int errnum) { return strerror(errnum); } 238613481Sgiacomo.travaglini@arm.com#endif 238713481Sgiacomo.travaglini@arm.cominline const char* GetEnv(const char* name) { 238813481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT 238913481Sgiacomo.travaglini@arm.com // We are on Windows CE, which has no environment variables. 239013481Sgiacomo.travaglini@arm.com static_cast<void>(name); // To prevent 'unused argument' warning. 239113481Sgiacomo.travaglini@arm.com return NULL; 239213481Sgiacomo.travaglini@arm.com#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 239313481Sgiacomo.travaglini@arm.com // Environment variables which we programmatically clear will be set to the 239413481Sgiacomo.travaglini@arm.com // empty string rather than unset (NULL). Handle that case. 239513481Sgiacomo.travaglini@arm.com const char* const env = getenv(name); 239613481Sgiacomo.travaglini@arm.com return (env != NULL && env[0] != '\0') ? env : NULL; 239713481Sgiacomo.travaglini@arm.com#else 239813481Sgiacomo.travaglini@arm.com return getenv(name); 239913481Sgiacomo.travaglini@arm.com#endif 240013481Sgiacomo.travaglini@arm.com} 240113481Sgiacomo.travaglini@arm.com 240213481Sgiacomo.travaglini@arm.comGTEST_DISABLE_MSC_WARNINGS_POP_() 240313481Sgiacomo.travaglini@arm.com 240413481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE 240513481Sgiacomo.travaglini@arm.com// Windows CE has no C library. The abort() function is used in 240613481Sgiacomo.travaglini@arm.com// several places in Google Test. This implementation provides a reasonable 240713481Sgiacomo.travaglini@arm.com// imitation of standard behaviour. 240813481Sgiacomo.travaglini@arm.comvoid Abort(); 240913481Sgiacomo.travaglini@arm.com#else 241013481Sgiacomo.travaglini@arm.cominline void Abort() { abort(); } 241113481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS_MOBILE 241213481Sgiacomo.travaglini@arm.com 241313481Sgiacomo.travaglini@arm.com} // namespace posix 241413481Sgiacomo.travaglini@arm.com 241513481Sgiacomo.travaglini@arm.com// MSVC "deprecates" snprintf and issues warnings wherever it is used. In 241613481Sgiacomo.travaglini@arm.com// order to avoid these warnings, we need to use _snprintf or _snprintf_s on 241713481Sgiacomo.travaglini@arm.com// MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate 241813481Sgiacomo.travaglini@arm.com// function in order to achieve that. We use macro definition here because 241913481Sgiacomo.travaglini@arm.com// snprintf is a variadic function. 242013481Sgiacomo.travaglini@arm.com#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 242113481Sgiacomo.travaglini@arm.com// MSVC 2005 and above support variadic macros. 242213481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_(buffer, size, format, ...) \ 242313481Sgiacomo.travaglini@arm.com _snprintf_s(buffer, size, size, format, __VA_ARGS__) 242413481Sgiacomo.travaglini@arm.com#elif defined(_MSC_VER) 242513481Sgiacomo.travaglini@arm.com// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't 242613481Sgiacomo.travaglini@arm.com// complain about _snprintf. 242713481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_ _snprintf 242813481Sgiacomo.travaglini@arm.com#else 242913481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_ snprintf 243013481Sgiacomo.travaglini@arm.com#endif 243113481Sgiacomo.travaglini@arm.com 243213481Sgiacomo.travaglini@arm.com// The maximum number a BiggestInt can represent. This definition 243313481Sgiacomo.travaglini@arm.com// works no matter BiggestInt is represented in one's complement or 243413481Sgiacomo.travaglini@arm.com// two's complement. 243513481Sgiacomo.travaglini@arm.com// 243613481Sgiacomo.travaglini@arm.com// We cannot rely on numeric_limits in STL, as __int64 and long long 243713481Sgiacomo.travaglini@arm.com// are not part of standard C++ and numeric_limits doesn't need to be 243813481Sgiacomo.travaglini@arm.com// defined for them. 243913481Sgiacomo.travaglini@arm.comconst BiggestInt kMaxBiggestInt = 244013481Sgiacomo.travaglini@arm.com ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 244113481Sgiacomo.travaglini@arm.com 244213481Sgiacomo.travaglini@arm.com// This template class serves as a compile-time function from size to 244313481Sgiacomo.travaglini@arm.com// type. It maps a size in bytes to a primitive type with that 244413481Sgiacomo.travaglini@arm.com// size. e.g. 244513481Sgiacomo.travaglini@arm.com// 244613481Sgiacomo.travaglini@arm.com// TypeWithSize<4>::UInt 244713481Sgiacomo.travaglini@arm.com// 244813481Sgiacomo.travaglini@arm.com// is typedef-ed to be unsigned int (unsigned integer made up of 4 244913481Sgiacomo.travaglini@arm.com// bytes). 245013481Sgiacomo.travaglini@arm.com// 245113481Sgiacomo.travaglini@arm.com// Such functionality should belong to STL, but I cannot find it 245213481Sgiacomo.travaglini@arm.com// there. 245313481Sgiacomo.travaglini@arm.com// 245413481Sgiacomo.travaglini@arm.com// Google Test uses this class in the implementation of floating-point 245513481Sgiacomo.travaglini@arm.com// comparison. 245613481Sgiacomo.travaglini@arm.com// 245713481Sgiacomo.travaglini@arm.com// For now it only handles UInt (unsigned int) as that's all Google Test 245813481Sgiacomo.travaglini@arm.com// needs. Other types can be easily added in the future if need 245913481Sgiacomo.travaglini@arm.com// arises. 246013481Sgiacomo.travaglini@arm.comtemplate <size_t size> 246113481Sgiacomo.travaglini@arm.comclass TypeWithSize { 246213481Sgiacomo.travaglini@arm.com public: 246313481Sgiacomo.travaglini@arm.com // This prevents the user from using TypeWithSize<N> with incorrect 246413481Sgiacomo.travaglini@arm.com // values of N. 246513481Sgiacomo.travaglini@arm.com typedef void UInt; 246613481Sgiacomo.travaglini@arm.com}; 246713481Sgiacomo.travaglini@arm.com 246813481Sgiacomo.travaglini@arm.com// The specialization for size 4. 246913481Sgiacomo.travaglini@arm.comtemplate <> 247013481Sgiacomo.travaglini@arm.comclass TypeWithSize<4> { 247113481Sgiacomo.travaglini@arm.com public: 247213481Sgiacomo.travaglini@arm.com // unsigned int has size 4 in both gcc and MSVC. 247313481Sgiacomo.travaglini@arm.com // 247413481Sgiacomo.travaglini@arm.com // As base/basictypes.h doesn't compile on Windows, we cannot use 247513481Sgiacomo.travaglini@arm.com // uint32, uint64, and etc here. 247613481Sgiacomo.travaglini@arm.com typedef int Int; 247713481Sgiacomo.travaglini@arm.com typedef unsigned int UInt; 247813481Sgiacomo.travaglini@arm.com}; 247913481Sgiacomo.travaglini@arm.com 248013481Sgiacomo.travaglini@arm.com// The specialization for size 8. 248113481Sgiacomo.travaglini@arm.comtemplate <> 248213481Sgiacomo.travaglini@arm.comclass TypeWithSize<8> { 248313481Sgiacomo.travaglini@arm.com public: 248413481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS 248513481Sgiacomo.travaglini@arm.com typedef __int64 Int; 248613481Sgiacomo.travaglini@arm.com typedef unsigned __int64 UInt; 248713481Sgiacomo.travaglini@arm.com#else 248813481Sgiacomo.travaglini@arm.com typedef long long Int; // NOLINT 248913481Sgiacomo.travaglini@arm.com typedef unsigned long long UInt; // NOLINT 249013481Sgiacomo.travaglini@arm.com#endif // GTEST_OS_WINDOWS 249113481Sgiacomo.travaglini@arm.com}; 249213481Sgiacomo.travaglini@arm.com 249313481Sgiacomo.travaglini@arm.com// Integer types of known sizes. 249413481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<4>::Int Int32; 249513481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<4>::UInt UInt32; 249613481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::Int Int64; 249713481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::UInt UInt64; 249813481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 249913481Sgiacomo.travaglini@arm.com 250013481Sgiacomo.travaglini@arm.com// Utilities for command line flags and environment variables. 250113481Sgiacomo.travaglini@arm.com 250213481Sgiacomo.travaglini@arm.com// Macro for referencing flags. 250313481Sgiacomo.travaglini@arm.com#if !defined(GTEST_FLAG) 250413481Sgiacomo.travaglini@arm.com# define GTEST_FLAG(name) FLAGS_gtest_##name 250513481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_FLAG) 250613481Sgiacomo.travaglini@arm.com 250713481Sgiacomo.travaglini@arm.com#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) 250813481Sgiacomo.travaglini@arm.com# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1 250913481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) 251013481Sgiacomo.travaglini@arm.com 251113481Sgiacomo.travaglini@arm.com#if !defined(GTEST_DECLARE_bool_) 251213481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver 251313481Sgiacomo.travaglini@arm.com 251413481Sgiacomo.travaglini@arm.com// Macros for declaring flags. 251513481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 251613481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_int32_(name) \ 251713481Sgiacomo.travaglini@arm.com GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 251813481Sgiacomo.travaglini@arm.com#define GTEST_DECLARE_string_(name) \ 251913481Sgiacomo.travaglini@arm.com GTEST_API_ extern ::std::string GTEST_FLAG(name) 252013481Sgiacomo.travaglini@arm.com 252113481Sgiacomo.travaglini@arm.com// Macros for defining flags. 252213481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_bool_(name, default_val, doc) \ 252313481Sgiacomo.travaglini@arm.com GTEST_API_ bool GTEST_FLAG(name) = (default_val) 252413481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_int32_(name, default_val, doc) \ 252513481Sgiacomo.travaglini@arm.com GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 252613481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_string_(name, default_val, doc) \ 252713481Sgiacomo.travaglini@arm.com GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) 252813481Sgiacomo.travaglini@arm.com 252913481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_DECLARE_bool_) 253013481Sgiacomo.travaglini@arm.com 253113481Sgiacomo.travaglini@arm.com// Thread annotations 253213481Sgiacomo.travaglini@arm.com#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) 253313481Sgiacomo.travaglini@arm.com# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) 253413481Sgiacomo.travaglini@arm.com# define GTEST_LOCK_EXCLUDED_(locks) 253513481Sgiacomo.travaglini@arm.com#endif // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) 253613481Sgiacomo.travaglini@arm.com 253713481Sgiacomo.travaglini@arm.com// Parses 'str' for a 32-bit signed integer. If successful, writes the result 253813481Sgiacomo.travaglini@arm.com// to *value and returns true; otherwise leaves *value unchanged and returns 253913481Sgiacomo.travaglini@arm.com// false. 254013481Sgiacomo.travaglini@arm.com// TODO(chandlerc): Find a better way to refactor flag and environment parsing 254113481Sgiacomo.travaglini@arm.com// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 254213481Sgiacomo.travaglini@arm.com// function. 254313481Sgiacomo.travaglini@arm.combool ParseInt32(const Message& src_text, const char* str, Int32* value); 254413481Sgiacomo.travaglini@arm.com 254513481Sgiacomo.travaglini@arm.com// Parses a bool/Int32/string from the environment variable 254613481Sgiacomo.travaglini@arm.com// corresponding to the given Google Test flag. 254713481Sgiacomo.travaglini@arm.combool BoolFromGTestEnv(const char* flag, bool default_val); 254813481Sgiacomo.travaglini@arm.comGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 254913481Sgiacomo.travaglini@arm.comstd::string StringFromGTestEnv(const char* flag, const char* default_val); 255013481Sgiacomo.travaglini@arm.com 255113481Sgiacomo.travaglini@arm.com} // namespace internal 255213481Sgiacomo.travaglini@arm.com} // namespace testing 255313481Sgiacomo.travaglini@arm.com 255413481Sgiacomo.travaglini@arm.com#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 2555