/Unittests/googletest/include/gtest/internal/gtest-port.h
C++ Header | 1084 lines | 613 code | 125 blank | 346 comment | 40 complexity | ad17d570d68a1a18b2752989f9c3bb85 MD5 | raw file
1// Copyright 2005, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29// 30// Authors: wan@google.com (Zhanyong Wan) 31// 32// Low-level types and utilities for porting Google Test to various 33// platforms. They are subject to change without notice. DO NOT USE 34// THEM IN USER CODE. 35 36#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 37#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 38 39// The user can define the following macros in the build script to 40// control Google Test's behavior. If the user doesn't define a macro 41// in this list, Google Test will define it. 42// 43// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) 44// is/isn't available. 45// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string 46// is/isn't available (some systems define 47// ::string, which is different to std::string). 48// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string 49// is/isn't available (some systems define 50// ::wstring, which is different to std::wstring). 51// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> 52// is/isn't available. 53// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't 54// enabled. 55// GTEST_HAS_STD_STRING - Define it to 1/0 to indicate that 56// std::string does/doesn't work (Google Test can 57// be used where std::string is unavailable). 58// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that 59// std::wstring does/doesn't work (Google Test can 60// be used where std::wstring is unavailable). 61// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple 62// is/isn't available. 63// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the 64// compiler supports Microsoft's "Structured 65// Exception Handling". 66// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google 67// Test's own tr1 tuple implementation should be 68// used. Unused when the user sets 69// GTEST_HAS_TR1_TUPLE to 0. 70 71// This header defines the following utilities: 72// 73// Macros indicating the current platform (defined to 1 if compiled on 74// the given platform; otherwise undefined): 75// GTEST_OS_CYGWIN - Cygwin 76// GTEST_OS_LINUX - Linux 77// GTEST_OS_MAC - Mac OS X 78// GTEST_OS_SOLARIS - Sun Solaris 79// GTEST_OS_SYMBIAN - Symbian 80// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) 81// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop 82// GTEST_OS_WINDOWS_MINGW - MinGW 83// GTEST_OS_WINODWS_MOBILE - Windows Mobile 84// GTEST_OS_ZOS - z/OS 85// 86// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 87// most stable support. Since core members of the Google Test project 88// don't have access to other platforms, support for them may be less 89// stable. If you notice any problems on your platform, please notify 90// googletestframework@googlegroups.com (patches for fixing them are 91// even more welcome!). 92// 93// Note that it is possible that none of the GTEST_OS_* macros are defined. 94// 95// Macros indicating available Google Test features (defined to 1 if 96// the corresponding feature is supported; otherwise undefined): 97// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 98// tests) 99// GTEST_HAS_DEATH_TEST - death tests 100// GTEST_HAS_PARAM_TEST - value-parameterized tests 101// GTEST_HAS_TYPED_TEST - typed tests 102// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 103// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 104// GTEST_USES_SIMPLE_RE - our own simple regex is used; 105// the above two are mutually exclusive. 106// 107// Macros for basic C++ coding: 108// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 109// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a 110// variable don't have to be used. 111// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 112// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 113// 114// Synchronization: 115// Mutex, MutexLock, ThreadLocal, GetThreadCount() 116// - synchronization primitives. 117// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 118// synchronization primitives have real implementations 119// and Google Test is thread-safe; or 0 otherwise. 120// 121// Template meta programming: 122// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 123// 124// Smart pointers: 125// scoped_ptr - as in TR2. 126// 127// Regular expressions: 128// RE - a simple regular expression class using the POSIX 129// Extended Regular Expression syntax. Not available on 130// Windows. 131// 132// Logging: 133// GTEST_LOG_() - logs messages at the specified severity level. 134// LogToStderr() - directs all log messages to stderr. 135// FlushInfoLog() - flushes informational log messages. 136// 137// Stderr capturing: 138// CaptureStderr() - starts capturing stderr. 139// GetCapturedStderr() - stops capturing stderr and returns the captured 140// string. 141// 142// Integer types: 143// TypeWithSize - maps an integer to a int type. 144// Int32, UInt32, Int64, UInt64, TimeInMillis 145// - integers of known sizes. 146// BiggestInt - the biggest signed integer type. 147// 148// Command-line utilities: 149// GTEST_FLAG() - references a flag. 150// GTEST_DECLARE_*() - declares a flag. 151// GTEST_DEFINE_*() - defines a flag. 152// GetArgvs() - returns the command line as a vector of strings. 153// 154// Environment variable utilities: 155// GetEnv() - gets the value of an environment variable. 156// BoolFromGTestEnv() - parses a bool environment variable. 157// Int32FromGTestEnv() - parses an Int32 environment variable. 158// StringFromGTestEnv() - parses a string environment variable. 159 160#include <stddef.h> // For ptrdiff_t 161#include <stdlib.h> 162#include <stdio.h> 163#include <string.h> 164#ifndef _WIN32_WCE 165#include <sys/stat.h> 166#endif // !_WIN32_WCE 167 168#include <iostream> // NOLINT 169 170#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 171#define GTEST_FLAG_PREFIX_ "gtest_" 172#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 173#define GTEST_NAME_ "Google Test" 174#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 175 176// Determines the version of gcc that is used to compile this. 177#ifdef __GNUC__ 178// 40302 means version 4.3.2. 179#define GTEST_GCC_VER_ \ 180 (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 181#endif // __GNUC__ 182 183// Determines the platform on which Google Test is compiled. 184#ifdef __CYGWIN__ 185#define GTEST_OS_CYGWIN 1 186#elif defined __SYMBIAN32__ 187#define GTEST_OS_SYMBIAN 1 188#elif defined _WIN32 189#define GTEST_OS_WINDOWS 1 190#ifdef _WIN32_WCE 191#define GTEST_OS_WINDOWS_MOBILE 1 192#elif defined(__MINGW__) || defined(__MINGW32__) 193#define GTEST_OS_WINDOWS_MINGW 1 194#else 195#define GTEST_OS_WINDOWS_DESKTOP 1 196#endif // _WIN32_WCE 197#elif defined __APPLE__ 198#define GTEST_OS_MAC 1 199#elif defined __linux__ 200#define GTEST_OS_LINUX 1 201#elif defined __MVS__ 202#define GTEST_OS_ZOS 1 203#elif defined(__sun) && defined(__SVR4) 204#define GTEST_OS_SOLARIS 1 205#endif // __CYGWIN__ 206 207#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \ 208 GTEST_OS_SOLARIS 209 210// On some platforms, <regex.h> needs someone to define size_t, and 211// won't compile otherwise. We can #include it here as we already 212// included <stdlib.h>, which is guaranteed to define size_t through 213// <stddef.h>. 214#include <regex.h> // NOLINT 215#include <strings.h> // NOLINT 216#include <sys/types.h> // NOLINT 217#include <unistd.h> // NOLINT 218 219#define GTEST_USES_POSIX_RE 1 220 221#elif GTEST_OS_WINDOWS 222 223#if !GTEST_OS_WINDOWS_MOBILE 224#include <direct.h> // NOLINT 225#include <io.h> // NOLINT 226#endif 227 228// <regex.h> is not available on Windows. Use our own simple regex 229// implementation instead. 230#define GTEST_USES_SIMPLE_RE 1 231 232#else 233 234// <regex.h> may not be available on this platform. Use our own 235// simple regex implementation instead. 236#define GTEST_USES_SIMPLE_RE 1 237 238#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || 239 // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS 240 241// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0 242// otherwise. 243 244#if defined(_MSC_VER) || defined(__BORLANDC__) 245// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS 246// macro to enable exceptions, so we'll do the same. 247// Assumes that exceptions are enabled by default. 248#ifndef _HAS_EXCEPTIONS 249#define _HAS_EXCEPTIONS 1 250#endif // _HAS_EXCEPTIONS 251#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 252#else // The compiler is not MSVC or C++Builder. 253// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For 254// other compilers, we assume exceptions are disabled to be 255// conservative. 256#if defined(__GNUC__) && __EXCEPTIONS 257#define GTEST_HAS_EXCEPTIONS 1 258#else 259#define GTEST_HAS_EXCEPTIONS 0 260#endif // defined(__GNUC__) && __EXCEPTIONS 261#endif // defined(_MSC_VER) || defined(__BORLANDC__) 262 263// Determines whether ::std::string and ::string are available. 264 265#ifndef GTEST_HAS_STD_STRING 266// The user didn't tell us whether ::std::string is available, so we 267// need to figure it out. The only environment that we know 268// ::std::string is not available is MSVC 7.1 or lower with exceptions 269// disabled. 270#if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS 271#define GTEST_HAS_STD_STRING 0 272#else 273#define GTEST_HAS_STD_STRING 1 274#endif 275#endif // GTEST_HAS_STD_STRING 276 277#ifndef GTEST_HAS_GLOBAL_STRING 278// The user didn't tell us whether ::string is available, so we need 279// to figure it out. 280 281#define GTEST_HAS_GLOBAL_STRING 0 282 283#endif // GTEST_HAS_GLOBAL_STRING 284 285#ifndef GTEST_HAS_STD_WSTRING 286// The user didn't tell us whether ::std::wstring is available, so we need 287// to figure it out. 288// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 289// is available. 290 291#if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS 292// Cygwin 1.5 and below doesn't support ::std::wstring. 293// Cygwin 1.7 might add wstring support; this should be updated when clear. 294// Solaris' libc++ doesn't support it either. 295#define GTEST_HAS_STD_WSTRING 0 296#else 297#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING 298#endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS 299 300#endif // GTEST_HAS_STD_WSTRING 301 302#ifndef GTEST_HAS_GLOBAL_WSTRING 303// The user didn't tell us whether ::wstring is available, so we need 304// to figure it out. 305#define GTEST_HAS_GLOBAL_WSTRING \ 306 (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 307#endif // GTEST_HAS_GLOBAL_WSTRING 308 309#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \ 310 GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 311#include <string> // NOLINT 312#endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || 313 // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 314 315#if GTEST_HAS_STD_STRING 316#include <sstream> // NOLINT 317#else 318#include <strstream> // NOLINT 319#endif // GTEST_HAS_STD_STRING 320 321// Determines whether RTTI is available. 322#ifndef GTEST_HAS_RTTI 323// The user didn't tell us whether RTTI is enabled, so we need to 324// figure it out. 325 326#ifdef _MSC_VER 327 328#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 329#define GTEST_HAS_RTTI 1 330#else 331#define GTEST_HAS_RTTI 0 332#endif // _CPPRTTI 333 334#elif defined(__GNUC__) 335 336// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 337#if GTEST_GCC_VER_ >= 40302 338#ifdef __GXX_RTTI 339#define GTEST_HAS_RTTI 1 340#else 341#define GTEST_HAS_RTTI 0 342#endif // __GXX_RTTI 343#else 344// For gcc versions smaller than 4.3.2, we assume RTTI is enabled. 345#define GTEST_HAS_RTTI 1 346#endif // GTEST_GCC_VER >= 40302 347 348#else 349 350// Unknown compiler - assume RTTI is enabled. 351#define GTEST_HAS_RTTI 1 352 353#endif // _MSC_VER 354 355#endif // GTEST_HAS_RTTI 356 357// Determines whether <pthread.h> is available. 358#ifndef GTEST_HAS_PTHREAD 359// The user didn't tell us, so we need to figure it out. 360#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) 361#endif // GTEST_HAS_PTHREAD 362 363// Determines whether Google Test can use tr1/tuple. You can define 364// this macro to 0 to prevent Google Test from using tuple (any 365// feature depending on tuple with be disabled in this mode). 366#ifndef GTEST_HAS_TR1_TUPLE 367// The user didn't tell us not to do it, so we assume it's OK. 368#define GTEST_HAS_TR1_TUPLE 1 369#endif // GTEST_HAS_TR1_TUPLE 370 371// Determines whether Google Test's own tr1 tuple implementation 372// should be used. 373#ifndef GTEST_USE_OWN_TR1_TUPLE 374// The user didn't tell us, so we need to figure it out. 375 376// We use our own tr1 tuple if we aren't sure the user has an 377// implementation of it already. At this time, GCC 4.0.0+ is the only 378// mainstream compiler that comes with a TR1 tuple implementation. 379// MSVC 2008 (9.0) provides TR1 tuple in a 323 MB Feature Pack 380// download, which we cannot assume the user has. MSVC 2010 isn't 381// released yet. 382#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 383#define GTEST_USE_OWN_TR1_TUPLE 0 384#else 385#define GTEST_USE_OWN_TR1_TUPLE 1 386#endif // defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 387 388#endif // GTEST_USE_OWN_TR1_TUPLE 389 390// To avoid conditional compilation everywhere, we make it 391// gtest-port.h's responsibility to #include the header implementing 392// tr1/tuple. 393#if GTEST_HAS_TR1_TUPLE 394 395#if GTEST_USE_OWN_TR1_TUPLE 396#include <gtest/internal/gtest-tuple.h> 397#elif GTEST_OS_SYMBIAN 398 399// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to 400// use STLport's tuple implementation, which unfortunately doesn't 401// work as the copy of STLport distributed with Symbian is incomplete. 402// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to 403// use its own tuple implementation. 404#ifdef BOOST_HAS_TR1_TUPLE 405#undef BOOST_HAS_TR1_TUPLE 406#endif // BOOST_HAS_TR1_TUPLE 407 408// This prevents <boost/tr1/detail/config.hpp>, which defines 409// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. 410#define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 411#include <tuple> 412 413#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 414// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does 415// not conform to the TR1 spec, which requires the header to be <tuple>. 416 417#if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 418// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, 419// which is #included by <tr1/tuple>, to not compile when RTTI is 420// disabled. _TR1_FUNCTIONAL is the header guard for 421// <tr1/functional>. Hence the following #define is a hack to prevent 422// <tr1/functional> from being included. 423#define _TR1_FUNCTIONAL 1 424#include <tr1/tuple> 425#undef _TR1_FUNCTIONAL // Allows the user to #include 426 // <tr1/functional> if he chooses to. 427#else 428#include <tr1/tuple> 429#endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 430 431#else 432// If the compiler is not GCC 4.0+, we assume the user is using a 433// spec-conforming TR1 implementation. 434#include <tuple> 435#endif // GTEST_USE_OWN_TR1_TUPLE 436 437#endif // GTEST_HAS_TR1_TUPLE 438 439// Determines whether clone(2) is supported. 440// Usually it will only be available on Linux, excluding 441// Linux on the Itanium architecture. 442// Also see http://linux.die.net/man/2/clone. 443#ifndef GTEST_HAS_CLONE 444// The user didn't tell us, so we need to figure it out. 445 446#if GTEST_OS_LINUX && !defined(__ia64__) 447#define GTEST_HAS_CLONE 1 448#else 449#define GTEST_HAS_CLONE 0 450#endif // GTEST_OS_LINUX && !defined(__ia64__) 451 452#endif // GTEST_HAS_CLONE 453 454// Determines whether to support death tests. 455// Google Test does not support death tests for VC 7.1 and earlier for 456// these reasons: 457// 1. std::vector does not build in VC 7.1 when exceptions are disabled. 458// 2. std::string does not build in VC 7.1 when exceptions are disabled 459// (this is covered by GTEST_HAS_STD_STRING guard). 460// 3. abort() in a VC 7.1 application compiled as GUI in debug config 461// pops up a dialog window that cannot be suppressed programmatically. 462#if GTEST_HAS_STD_STRING && \ 463 (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || \ 464 (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW) 465#define GTEST_HAS_DEATH_TEST 1 466#include <vector> // NOLINT 467#endif 468 469// Determines whether to support value-parameterized tests. 470 471#if defined(__GNUC__) || (_MSC_VER >= 1400) 472// TODO(vladl@google.com): get the implementation rid of vector and list 473// to compile on MSVC 7.1. 474#define GTEST_HAS_PARAM_TEST 1 475#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 476 477// Determines whether to support type-driven tests. 478 479// Typed tests need <typeinfo> and variadic macros, which gcc and VC 480// 8.0+ support. 481#if defined(__GNUC__) || (_MSC_VER >= 1400) 482#define GTEST_HAS_TYPED_TEST 1 483#define GTEST_HAS_TYPED_TEST_P 1 484#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 485 486// Determines whether to support Combine(). This only makes sense when 487// value-parameterized tests are enabled. 488#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 489#define GTEST_HAS_COMBINE 1 490#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 491 492// Determines whether the system compiler uses UTF-16 for encoding wide strings. 493#define GTEST_WIDE_STRING_USES_UTF16_ \ 494 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN) 495 496// Defines some utility macros. 497 498// The GNU compiler emits a warning if nested "if" statements are followed by 499// an "else" statement and braces are not used to explicitly disambiguate the 500// "else" binding. This leads to problems with code like: 501// 502// if (gate) 503// ASSERT_*(condition) << "Some message"; 504// 505// The "switch (0) case 0:" idiom is used to suppress this. 506#ifdef __INTEL_COMPILER 507#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 508#else 509#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 510#endif 511 512// Use this annotation at the end of a struct/class definition to 513// prevent the compiler from optimizing away instances that are never 514// used. This is useful when all interesting logic happens inside the 515// c'tor and / or d'tor. Example: 516// 517// struct Foo { 518// Foo() { ... } 519// } GTEST_ATTRIBUTE_UNUSED_; 520// 521// Also use it after a variable or parameter declaration to tell the 522// compiler the variable/parameter does not have to be used. 523#if defined(__GNUC__) && !defined(COMPILER_ICC) 524#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 525#else 526#define GTEST_ATTRIBUTE_UNUSED_ 527#endif 528 529// A macro to disallow the evil copy constructor and operator= functions 530// This should be used in the private: declarations for a class. 531#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 532 type(const type &);\ 533 void operator=(const type &) 534 535// Tell the compiler to warn about unused return values for functions declared 536// with this macro. The macro should be used on function declarations 537// following the argument list: 538// 539// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 540#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 541#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 542#else 543#define GTEST_MUST_USE_RESULT_ 544#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 545 546// Determine whether the compiler supports Microsoft's Structured Exception 547// Handling. This is supported by several Windows compilers but generally 548// does not exist on any other system. 549#ifndef GTEST_HAS_SEH 550// The user didn't tell us, so we need to figure it out. 551 552#if defined(_MSC_VER) || defined(__BORLANDC__) 553// These two compilers are known to support SEH. 554#define GTEST_HAS_SEH 1 555#else 556// Assume no SEH. 557#define GTEST_HAS_SEH 0 558#endif 559 560#endif // GTEST_HAS_SEH 561 562namespace testing { 563 564class Message; 565 566namespace internal { 567 568class String; 569 570// std::strstream is deprecated. However, we have to use it on 571// Windows as std::stringstream won't compile on Windows when 572// exceptions are disabled. We use std::stringstream on other 573// platforms to avoid compiler warnings there. 574#if GTEST_HAS_STD_STRING 575typedef ::std::stringstream StrStream; 576#else 577typedef ::std::strstream StrStream; 578#endif // GTEST_HAS_STD_STRING 579 580// A helper for suppressing warnings on constant condition. It just 581// returns 'condition'. 582bool IsTrue(bool condition); 583 584// Defines scoped_ptr. 585 586// This implementation of scoped_ptr is PARTIAL - it only contains 587// enough stuff to satisfy Google Test's need. 588template <typename T> 589class scoped_ptr { 590 public: 591 explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 592 ~scoped_ptr() { reset(); } 593 594 T& operator*() const { return *ptr_; } 595 T* operator->() const { return ptr_; } 596 T* get() const { return ptr_; } 597 598 T* release() { 599 T* const ptr = ptr_; 600 ptr_ = NULL; 601 return ptr; 602 } 603 604 void reset(T* p = NULL) { 605 if (p != ptr_) { 606 if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. 607 delete ptr_; 608 } 609 ptr_ = p; 610 } 611 } 612 private: 613 T* ptr_; 614 615 GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 616}; 617 618// Defines RE. 619 620// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended 621// Regular Expression syntax. 622class RE { 623 public: 624 // Constructs an RE from a string. 625#if GTEST_HAS_STD_STRING 626 RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 627#endif // GTEST_HAS_STD_STRING 628 629#if GTEST_HAS_GLOBAL_STRING 630 RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 631#endif // GTEST_HAS_GLOBAL_STRING 632 633 RE(const char* regex) { Init(regex); } // NOLINT 634 ~RE(); 635 636 // Returns the string representation of the regex. 637 const char* pattern() const { return pattern_; } 638 639 // FullMatch(str, re) returns true iff regular expression re matches 640 // the entire str. 641 // PartialMatch(str, re) returns true iff regular expression re 642 // matches a substring of str (including str itself). 643 // 644 // TODO(wan@google.com): make FullMatch() and PartialMatch() work 645 // when str contains NUL characters. 646#if GTEST_HAS_STD_STRING 647 static bool FullMatch(const ::std::string& str, const RE& re) { 648 return FullMatch(str.c_str(), re); 649 } 650 static bool PartialMatch(const ::std::string& str, const RE& re) { 651 return PartialMatch(str.c_str(), re); 652 } 653#endif // GTEST_HAS_STD_STRING 654 655#if GTEST_HAS_GLOBAL_STRING 656 static bool FullMatch(const ::string& str, const RE& re) { 657 return FullMatch(str.c_str(), re); 658 } 659 static bool PartialMatch(const ::string& str, const RE& re) { 660 return PartialMatch(str.c_str(), re); 661 } 662#endif // GTEST_HAS_GLOBAL_STRING 663 664 static bool FullMatch(const char* str, const RE& re); 665 static bool PartialMatch(const char* str, const RE& re); 666 667 private: 668 void Init(const char* regex); 669 670 // We use a const char* instead of a string, as Google Test may be used 671 // where string is not available. We also do not use Google Test's own 672 // String type here, in order to simplify dependencies between the 673 // files. 674 const char* pattern_; 675 bool is_valid_; 676#if GTEST_USES_POSIX_RE 677 regex_t full_regex_; // For FullMatch(). 678 regex_t partial_regex_; // For PartialMatch(). 679#else // GTEST_USES_SIMPLE_RE 680 const char* full_pattern_; // For FullMatch(); 681#endif 682 683 GTEST_DISALLOW_COPY_AND_ASSIGN_(RE); 684}; 685 686// Defines logging utilities: 687// GTEST_LOG_(severity) - logs messages at the specified severity level. The 688// message itself is streamed into the macro. 689// LogToStderr() - directs all log messages to stderr. 690// FlushInfoLog() - flushes informational log messages. 691 692enum GTestLogSeverity { 693 GTEST_INFO, 694 GTEST_WARNING, 695 GTEST_ERROR, 696 GTEST_FATAL 697}; 698 699// Formats log entry severity, provides a stream object for streaming the 700// log message, and terminates the message with a newline when going out of 701// scope. 702class GTestLog { 703 public: 704 GTestLog(GTestLogSeverity severity, const char* file, int line); 705 706 // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. 707 ~GTestLog(); 708 709 ::std::ostream& GetStream() { return ::std::cerr; } 710 711 private: 712 const GTestLogSeverity severity_; 713 714 GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); 715}; 716 717#define GTEST_LOG_(severity) \ 718 ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 719 __FILE__, __LINE__).GetStream() 720 721inline void LogToStderr() {} 722inline void FlushInfoLog() { fflush(NULL); } 723 724// Defines the stderr capturer: 725// CaptureStderr - starts capturing stderr. 726// GetCapturedStderr - stops capturing stderr and returns the captured string. 727 728void CaptureStderr(); 729String GetCapturedStderr(); 730 731#if GTEST_HAS_DEATH_TEST 732 733// A copy of all command line arguments. Set by InitGoogleTest(). 734extern ::std::vector<String> g_argvs; 735 736// GTEST_HAS_DEATH_TEST implies we have ::std::string. 737const ::std::vector<String>& GetArgvs(); 738 739#endif // GTEST_HAS_DEATH_TEST 740 741// Defines synchronization primitives. 742 743// A dummy implementation of synchronization primitives (mutex, lock, 744// and thread-local variable). Necessary for compiling Google Test where 745// mutex is not supported - using Google Test in multiple threads is not 746// supported on such platforms. 747 748class Mutex { 749 public: 750 Mutex() {} 751 explicit Mutex(int /*unused*/) {} 752 void AssertHeld() const {} 753 enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 }; 754}; 755 756// We cannot call it MutexLock directly as the ctor declaration would 757// conflict with a macro named MutexLock, which is defined on some 758// platforms. Hence the typedef trick below. 759class GTestMutexLock { 760 public: 761 explicit GTestMutexLock(Mutex*) {} // NOLINT 762}; 763 764typedef GTestMutexLock MutexLock; 765 766template <typename T> 767class ThreadLocal { 768 public: 769 ThreadLocal() : value_() {} 770 explicit ThreadLocal(const T& value) : value_(value) {} 771 T* pointer() { return &value_; } 772 const T* pointer() const { return &value_; } 773 const T& get() const { return value_; } 774 void set(const T& value) { value_ = value; } 775 private: 776 T value_; 777}; 778 779// Returns the number of threads running in the process, or 0 to indicate that 780// we cannot detect it. 781size_t GetThreadCount(); 782 783// The above synchronization primitives have dummy implementations. 784// Therefore Google Test is not thread-safe. 785#define GTEST_IS_THREADSAFE 0 786 787#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 788 789// Passing non-POD classes through ellipsis (...) crashes the ARM 790// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to 791// instantiate a copy constructor for objects passed through ellipsis 792// (...), failing for uncopyable objects. We define this to indicate 793// the fact. 794#define GTEST_ELLIPSIS_NEEDS_COPY_ 1 795 796// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 797// const T& and const T* in a function template. These compilers 798// _can_ decide between class template specializations for T and T*, 799// so a tr1::type_traits-like is_pointer works. 800#define GTEST_NEEDS_IS_POINTER_ 1 801 802#endif // defined(__SYMBIAN32__) || defined(__IBMCPP__) 803 804template <bool bool_value> 805struct bool_constant { 806 typedef bool_constant<bool_value> type; 807 static const bool value = bool_value; 808}; 809template <bool bool_value> const bool bool_constant<bool_value>::value; 810 811typedef bool_constant<false> false_type; 812typedef bool_constant<true> true_type; 813 814template <typename T> 815struct is_pointer : public false_type {}; 816 817template <typename T> 818struct is_pointer<T*> : public true_type {}; 819 820#if GTEST_OS_WINDOWS 821#define GTEST_PATH_SEP_ "\\" 822// The biggest signed integer type the compiler supports. 823typedef __int64 BiggestInt; 824#else 825#define GTEST_PATH_SEP_ "/" 826typedef long long BiggestInt; // NOLINT 827#endif // GTEST_OS_WINDOWS 828 829// The testing::internal::posix namespace holds wrappers for common 830// POSIX functions. These wrappers hide the differences between 831// Windows/MSVC and POSIX systems. Since some compilers define these 832// standard functions as macros, the wrapper cannot have the same name 833// as the wrapped function. 834 835namespace posix { 836 837// Functions with a different name on Windows. 838 839#if GTEST_OS_WINDOWS 840 841typedef struct _stat StatStruct; 842 843#ifdef __BORLANDC__ 844inline int IsATTY(int fd) { return isatty(fd); } 845inline int StrCaseCmp(const char* s1, const char* s2) { 846 return stricmp(s1, s2); 847} 848inline char* StrDup(const char* src) { return strdup(src); } 849#else // !__BORLANDC__ 850#if GTEST_OS_WINDOWS_MOBILE 851inline int IsATTY(int /* fd */) { return 0; } 852#else 853inline int IsATTY(int fd) { return _isatty(fd); } 854#endif // GTEST_OS_WINDOWS_MOBILE 855inline int StrCaseCmp(const char* s1, const char* s2) { 856 return _stricmp(s1, s2); 857} 858inline char* StrDup(const char* src) { return _strdup(src); } 859#endif // __BORLANDC__ 860 861#if GTEST_OS_WINDOWS_MOBILE 862inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } 863// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this 864// time and thus not defined there. 865#else 866inline int FileNo(FILE* file) { return _fileno(file); } 867inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } 868inline int RmDir(const char* dir) { return _rmdir(dir); } 869inline bool IsDir(const StatStruct& st) { 870 return (_S_IFDIR & st.st_mode) != 0; 871} 872#endif // GTEST_OS_WINDOWS_MOBILE 873 874#else 875 876typedef struct stat StatStruct; 877 878inline int FileNo(FILE* file) { return fileno(file); } 879inline int IsATTY(int fd) { return isatty(fd); } 880inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } 881inline int StrCaseCmp(const char* s1, const char* s2) { 882 return strcasecmp(s1, s2); 883} 884inline char* StrDup(const char* src) { return strdup(src); } 885inline int RmDir(const char* dir) { return rmdir(dir); } 886inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 887 888#endif // GTEST_OS_WINDOWS 889 890// Functions deprecated by MSVC 8.0. 891 892#ifdef _MSC_VER 893// Temporarily disable warning 4996 (deprecated function). 894#pragma warning(push) 895#pragma warning(disable:4996) 896#endif 897 898inline const char* StrNCpy(char* dest, const char* src, size_t n) { 899 return strncpy(dest, src, n); 900} 901 902// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and 903// StrError() aren't needed on Windows CE at this time and thus not 904// defined there. 905 906#if !GTEST_OS_WINDOWS_MOBILE 907inline int ChDir(const char* dir) { return chdir(dir); } 908#endif 909inline FILE* FOpen(const char* path, const char* mode) { 910 return fopen(path, mode); 911} 912#if !GTEST_OS_WINDOWS_MOBILE 913inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { 914 return freopen(path, mode, stream); 915} 916inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } 917#endif 918inline int FClose(FILE* fp) { return fclose(fp); } 919#if !GTEST_OS_WINDOWS_MOBILE 920inline int Read(int fd, void* buf, unsigned int count) { 921 return static_cast<int>(read(fd, buf, count)); 922} 923inline int Write(int fd, const void* buf, unsigned int count) { 924 return static_cast<int>(write(fd, buf, count)); 925} 926inline int Close(int fd) { return close(fd); } 927inline const char* StrError(int errnum) { return strerror(errnum); } 928#endif 929inline const char* GetEnv(const char* name) { 930#if GTEST_OS_WINDOWS_MOBILE 931 // We are on Windows CE, which has no environment variables. 932 return NULL; 933#elif defined(__BORLANDC__) 934 // Environment variables which we programmatically clear will be set to the 935 // empty string rather than unset (NULL). Handle that case. 936 const char* const env = getenv(name); 937 return (env != NULL && env[0] != '\0') ? env : NULL; 938#else 939 return getenv(name); 940#endif 941} 942 943#ifdef _MSC_VER 944#pragma warning(pop) // Restores the warning state. 945#endif 946 947#if GTEST_OS_WINDOWS_MOBILE 948// Windows CE has no C library. The abort() function is used in 949// several places in Google Test. This implementation provides a reasonable 950// imitation of standard behaviour. 951void Abort(); 952#else 953inline void Abort() { abort(); } 954#endif // GTEST_OS_WINDOWS_MOBILE 955 956} // namespace posix 957 958// The maximum number a BiggestInt can represent. This definition 959// works no matter BiggestInt is represented in one's complement or 960// two's complement. 961// 962// We cannot rely on numeric_limits in STL, as __int64 and long long 963// are not part of standard C++ and numeric_limits doesn't need to be 964// defined for them. 965const BiggestInt kMaxBiggestInt = 966 ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 967 968// This template class serves as a compile-time function from size to 969// type. It maps a size in bytes to a primitive type with that 970// size. e.g. 971// 972// TypeWithSize<4>::UInt 973// 974// is typedef-ed to be unsigned int (unsigned integer made up of 4 975// bytes). 976// 977// Such functionality should belong to STL, but I cannot find it 978// there. 979// 980// Google Test uses this class in the implementation of floating-point 981// comparison. 982// 983// For now it only handles UInt (unsigned int) as that's all Google Test 984// needs. Other types can be easily added in the future if need 985// arises. 986template <size_t size> 987class TypeWithSize { 988 public: 989 // This prevents the user from using TypeWithSize<N> with incorrect 990 // values of N. 991 typedef void UInt; 992}; 993 994// The specialization for size 4. 995template <> 996class TypeWithSize<4> { 997 public: 998 // unsigned int has size 4 in both gcc and MSVC. 999 // 1000 // As base/basictypes.h doesn't compile on Windows, we cannot use 1001 // uint32, uint64, and etc here. 1002 typedef int Int; 1003 typedef unsigned int UInt; 1004}; 1005 1006// The specialization for size 8. 1007template <> 1008class TypeWithSize<8> { 1009 public: 1010#if GTEST_OS_WINDOWS 1011 typedef __int64 Int; 1012 typedef unsigned __int64 UInt; 1013#else 1014 typedef long long Int; // NOLINT 1015 typedef unsigned long long UInt; // NOLINT 1016#endif // GTEST_OS_WINDOWS 1017}; 1018 1019// Integer types of known sizes. 1020typedef TypeWithSize<4>::Int Int32; 1021typedef TypeWithSize<4>::UInt UInt32; 1022typedef TypeWithSize<8>::Int Int64; 1023typedef TypeWithSize<8>::UInt UInt64; 1024typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 1025 1026// Utilities for command line flags and environment variables. 1027 1028// INTERNAL IMPLEMENTATION - DO NOT USE. 1029// 1030// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 1031// is not satisfied. 1032// Synopsys: 1033// GTEST_CHECK_(boolean_condition); 1034// or 1035// GTEST_CHECK_(boolean_condition) << "Additional message"; 1036// 1037// This checks the condition and if the condition is not satisfied 1038// it prints message about the condition violation, including the 1039// condition itself, plus additional message streamed into it, if any, 1040// and then it aborts the program. It aborts the program irrespective of 1041// whether it is built in the debug mode or not. 1042#define GTEST_CHECK_(condition) \ 1043 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1044 if (::testing::internal::IsTrue(condition)) \ 1045 ; \ 1046 else \ 1047 GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 1048 1049// Macro for referencing flags. 1050#define GTEST_FLAG(name) FLAGS_gtest_##name 1051 1052// Macros for declaring flags. 1053#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name) 1054#define GTEST_DECLARE_int32_(name) \ 1055 extern ::testing::internal::Int32 GTEST_FLAG(name) 1056#define GTEST_DECLARE_string_(name) \ 1057 extern ::testing::internal::String GTEST_FLAG(name) 1058 1059// Macros for defining flags. 1060#define GTEST_DEFINE_bool_(name, default_val, doc) \ 1061 bool GTEST_FLAG(name) = (default_val) 1062#define GTEST_DEFINE_int32_(name, default_val, doc) \ 1063 ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 1064#define GTEST_DEFINE_string_(name, default_val, doc) \ 1065 ::testing::internal::String GTEST_FLAG(name) = (default_val) 1066 1067// Parses 'str' for a 32-bit signed integer. If successful, writes the result 1068// to *value and returns true; otherwise leaves *value unchanged and returns 1069// false. 1070// TODO(chandlerc): Find a better way to refactor flag and environment parsing 1071// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 1072// function. 1073bool ParseInt32(const Message& src_text, const char* str, Int32* value); 1074 1075// Parses a bool/Int32/string from the environment variable 1076// corresponding to the given Google Test flag. 1077bool BoolFromGTestEnv(const char* flag, bool default_val); 1078Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 1079const char* StringFromGTestEnv(const char* flag, const char* default_val); 1080 1081} // namespace internal 1082} // namespace testing 1083 1084#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_