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 1 - Define it to 1/0 to indicate tr1::tuple 62// is/isn't available. 63 64// This header defines the following utilities: 65// 66// Macros indicating the current platform (defined to 1 if compiled on 67// the given platform; otherwise undefined): 68// GTEST_OS_ANDROID - Android 69// GTEST_OS_CYGWIN - Cygwin 70// GTEST_OS_LINUX - Linux 71// GTEST_OS_MAC - Mac OS X 72// GTEST_OS_SOLARIS - Sun Solaris 73// GTEST_OS_SYMBIAN - Symbian 74// GTEST_OS_WINDOWS - Windows 75// GTEST_OS_ZOS - z/OS 76// 77// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the 78// most stable support. Since core members of the Google Test project 79// don't have access to other platforms, support for them may be less 80// stable. If you notice any problems on your platform, please notify 81// googletestframework@googlegroups.com (patches for fixing them are 82// even more welcome!). 83// 84// Note that it is possible that none of the GTEST_OS_* macros are defined. 85// 86// Macros indicating available Google Test features (defined to 1 if 87// the corresponding feature is supported; otherwise undefined): 88// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized 89// tests) 90// GTEST_HAS_DEATH_TEST - death tests 91// GTEST_HAS_PARAM_TEST - value-parameterized tests 92// GTEST_HAS_TYPED_TEST - typed tests 93// GTEST_HAS_TYPED_TEST_P - type-parameterized tests 94// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. 95// GTEST_USES_SIMPLE_RE - our own simple regex is used; 96// the above two are mutually exclusive. 97// 98// Macros for basic C++ coding: 99// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. 100// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances don't have to 101// be used. 102// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. 103// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. 104// 105// Synchronization: 106// Mutex, MutexLock, ThreadLocal, GetThreadCount() 107// - synchronization primitives. 108// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above 109// synchronization primitives have real implementations 110// and Google Test is thread-safe; or 0 otherwise. 111// 112// Template meta programming: 113// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. 114// 115// Smart pointers: 116// scoped_ptr - as in TR2. 117// 118// Regular expressions: 119// RE - a simple regular expression class using the POSIX 120// Extended Regular Expression syntax. Not available on 121// Windows. 122// 123// Logging: 124// GTEST_LOG_() - logs messages at the specified severity level. 125// LogToStderr() - directs all log messages to stderr. 126// FlushInfoLog() - flushes informational log messages. 127// 128// Stderr capturing: 129// CaptureStderr() - starts capturing stderr. 130// GetCapturedStderr() - stops capturing stderr and returns the captured 131// string. 132// 133// Integer types: 134// TypeWithSize - maps an integer to a int type. 135// Int32, UInt32, Int64, UInt64, TimeInMillis 136// - integers of known sizes. 137// BiggestInt - the biggest signed integer type. 138// 139// Command-line utilities: 140// GTEST_FLAG() - references a flag. 141// GTEST_DECLARE_*() - declares a flag. 142// GTEST_DEFINE_*() - defines a flag. 143// GetArgvs() - returns the command line as a vector of strings. 144// 145// Environment variable utilities: 146// GetEnv() - gets the value of an environment variable. 147// BoolFromGTestEnv() - parses a bool environment variable. 148// Int32FromGTestEnv() - parses an Int32 environment variable. 149// StringFromGTestEnv() - parses a string environment variable. 150 151#include <stdlib.h> 152#include <stdio.h> 153#include <iostream> // Used for GTEST_CHECK_ 154 155#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 156#define GTEST_FLAG_PREFIX_ "gtest_" 157#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 158#define GTEST_NAME_ "Google Test" 159#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" 160 161// Determines the version of gcc that is used to compile this. 162#ifdef __GNUC__ 163// 40302 means version 4.3.2. 164#define GTEST_GCC_VER_ \ 165 (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 166#endif // __GNUC__ 167 168// Determines the platform on which Google Test is compiled. 169#ifdef __CYGWIN__ 170#define GTEST_OS_CYGWIN 1 171#elif __SYMBIAN32__ 172#define GTEST_OS_SYMBIAN 1 173#elif defined _MSC_VER 174// TODO(kenton@google.com): GTEST_OS_WINDOWS is currently used to mean 175// both "The OS is Windows" and "The compiler is MSVC". These 176// meanings really should be separated in order to better support 177// Windows compilers other than MSVC. 178#define GTEST_OS_WINDOWS 1 179#elif defined __APPLE__ 180#define GTEST_OS_MAC 1 181#elif defined ANDROID 182#define GTEST_OS_ANDROID 1 183#elif defined __linux__ 184#define GTEST_OS_LINUX 1 185#elif defined __MVS__ 186#define GTEST_OS_ZOS 1 187#elif defined(__sun) && defined(__SVR4) 188#define GTEST_OS_SOLARIS 1 189#endif // _MSC_VER 190 191#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC 192 193// On some platforms, <regex.h> needs someone to define size_t, and 194// won't compile otherwise. We can #include it here as we already 195// included <stdlib.h>, which is guaranteed to define size_t through 196// <stddef.h>. 197#include <regex.h> // NOLINT 198#define GTEST_USES_POSIX_RE 1 199 200#else 201 202// <regex.h> may not be available on this platform. Use our own 203// simple regex implementation instead. 204#define GTEST_USES_SIMPLE_RE 1 205 206#endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC 207 208// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0 209// otherwise. 210 211#ifdef _MSC_VER // Compiled by MSVC? 212// Assumes that exceptions are enabled by default. 213#ifndef _HAS_EXCEPTIONS // MSVC uses this macro to enable exceptions. 214#define _HAS_EXCEPTIONS 1 215#endif // _HAS_EXCEPTIONS 216#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 217#else // The compiler is not MSVC. 218// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For 219// other compilers, we assume exceptions are disabled to be 220// conservative. 221#if defined(__GNUC__) && __EXCEPTIONS 222#define GTEST_HAS_EXCEPTIONS 1 223#else 224#define GTEST_HAS_EXCEPTIONS 0 225#endif // defined(__GNUC__) && __EXCEPTIONS 226#endif // _MSC_VER 227 228// Determines whether ::std::string and ::string are available. 229 230#ifndef GTEST_HAS_STD_STRING 231// The user didn't tell us whether ::std::string is available, so we 232// need to figure it out. The only environment that we know 233// ::std::string is not available is MSVC 7.1 or lower with exceptions 234// disabled. 235#if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS 236#define GTEST_HAS_STD_STRING 0 237#else 238#define GTEST_HAS_STD_STRING 1 239#endif 240#endif // GTEST_HAS_STD_STRING 241 242#ifndef GTEST_HAS_GLOBAL_STRING 243// The user didn't tell us whether ::string is available, so we need 244// to figure it out. 245 246#define GTEST_HAS_GLOBAL_STRING 0 247 248#endif // GTEST_HAS_GLOBAL_STRING 249 250#ifndef GTEST_HAS_STD_WSTRING 251// The user didn't tell us whether ::std::wstring is available, so we need 252// to figure it out. 253// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring 254// is available. 255 256#if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || GTEST_OS_ANDROID 257// Cygwin 1.5 and below doesn't support ::std::wstring. 258// Cygwin 1.7 might add wstring support; this should be updated when clear. 259// Solaris' libc++ doesn't support it either. 260// Android does not support wstring and never will. 261#define GTEST_HAS_STD_WSTRING 0 262#else 263#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING 264#endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS 265 266#endif // GTEST_HAS_STD_WSTRING 267 268#ifndef GTEST_HAS_GLOBAL_WSTRING 269// The user didn't tell us whether ::wstring is available, so we need 270// to figure it out. 271#define GTEST_HAS_GLOBAL_WSTRING \ 272 (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 273#endif // GTEST_HAS_GLOBAL_WSTRING 274 275#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \ 276 GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 277#include <string> // NOLINT 278#endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || 279 // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING 280 281#if GTEST_HAS_STD_STRING 282#include <sstream> // NOLINT 283#else 284#include <strstream> // NOLINT 285#endif // GTEST_HAS_STD_STRING 286 287// Determines whether RTTI is available. 288#ifndef GTEST_HAS_RTTI 289// The user didn't tell us whether RTTI is enabled, so we need to 290// figure it out. 291 292#ifdef _MSC_VER 293 294#ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 295#define GTEST_HAS_RTTI 1 296#else 297#define GTEST_HAS_RTTI 0 298#endif // _CPPRTTI 299 300#elif defined(__GNUC__) 301 302// Android uses GCC but does not support RTTI 303#if GTEST_OS_ANDROID 304#define GTEST_HAS_RTTI 0 305#else 306// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. 307#if GTEST_GCC_VER_ >= 40302 308#ifdef __GXX_RTTI 309#define GTEST_HAS_RTTI 1 310#else 311#define GTEST_HAS_RTTI 0 312#endif // __GXX_RTTI 313#else 314// For gcc versions smaller than 4.3.2, we assume RTTI is enabled. 315#define GTEST_HAS_RTTI 1 316#endif // GTEST_GCC_VER >= 40302 317#endif // GTEST_OS_ANDROID 318 319#else 320 321// Unknown compiler - assume RTTI is enabled. 322#define GTEST_HAS_RTTI 1 323 324#endif // _MSC_VER 325 326#endif // GTEST_HAS_RTTI 327 328// Determines whether <pthread.h> is available. 329#ifndef GTEST_HAS_PTHREAD 330// The user didn't tell us, so we need to figure it out. 331#define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) 332#endif // GTEST_HAS_PTHREAD 333 334// Determines whether tr1/tuple is available. If you have tr1/tuple 335// on your platform, define GTEST_HAS_TR1_TUPLE=1 for both the Google 336// Test project and your tests. If you would like Google Test to detect 337// tr1/tuple on your platform automatically, please open an issue 338// ticket at http://code.google.com/p/googletest. 339#ifndef GTEST_HAS_TR1_TUPLE 340// The user didn't tell us, so we need to figure it out. 341 342// GCC provides <tr1/tuple> since 4.0.0. 343#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) && !GTEST_OS_ANDROID 344#define GTEST_HAS_TR1_TUPLE 1 345#else 346#define GTEST_HAS_TR1_TUPLE 0 347#endif // __GNUC__ 348#endif // GTEST_HAS_TR1_TUPLE 349 350// To avoid conditional compilation everywhere, we make it 351// gtest-port.h's responsibility to #include the header implementing 352// tr1/tuple. 353#if GTEST_HAS_TR1_TUPLE 354#if defined(__GNUC__) 355// GCC implements tr1/tuple in the <tr1/tuple> header. This does not 356// conform to the TR1 spec, which requires the header to be <tuple>. 357#include <tr1/tuple> 358#else 359// If the compiler is not GCC, we assume the user is using a 360// spec-conforming TR1 implementation. 361#include <tuple> 362#endif // __GNUC__ 363#endif // GTEST_HAS_TR1_TUPLE 364 365// Determines whether clone(2) is supported. 366// Usually it will only be available on Linux, excluding 367// Linux on the Itanium architecture. 368// Also see http://linux.die.net/man/2/clone. 369#ifndef GTEST_HAS_CLONE 370// The user didn't tell us, so we need to figure it out. 371 372#if GTEST_OS_LINUX && !defined(__ia64__) 373#define GTEST_HAS_CLONE 1 374#else 375#define GTEST_HAS_CLONE 0 376#endif // GTEST_OS_LINUX && !defined(__ia64__) 377 378#endif // GTEST_HAS_CLONE 379 380// Determines whether to support death tests. 381// Google Test does not support death tests for VC 7.1 and earlier for 382// these reasons: 383// 1. std::vector does not build in VC 7.1 when exceptions are disabled. 384// 2. std::string does not build in VC 7.1 when exceptions are disabled 385// (this is covered by GTEST_HAS_STD_STRING guard). 386// 3. abort() in a VC 7.1 application compiled as GUI in debug config 387// pops up a dialog window that cannot be suppressed programmatically. 388#if GTEST_HAS_STD_STRING && (GTEST_OS_LINUX || \ 389 GTEST_OS_MAC || \ 390 GTEST_OS_CYGWIN || \ 391 (GTEST_OS_WINDOWS && _MSC_VER >= 1400)) 392#define GTEST_HAS_DEATH_TEST 1 393#include <vector> 394#endif 395 396// Determines whether to support value-parameterized tests. 397 398#if defined(__GNUC__) || (_MSC_VER >= 1400) 399// TODO(vladl@google.com): get the implementation rid of vector and list 400// to compile on MSVC 7.1. 401#define GTEST_HAS_PARAM_TEST 1 402#endif // defined(__GNUC__) || (_MSC_VER >= 1400) 403 404// Determines whether to support type-driven tests. 405 406// Typed tests need <typeinfo> and variadic macros, which gcc and VC 407// 8.0+ support. 408// TODO: We should be able to support these on Android but we don't 409// have cxxabi.h when building for the target but we have it for the host. 410#if ( defined(__GNUC__) || (_MSC_VER >= 1400) ) && !defined(GTEST_OS_ANDROID) 411#define GTEST_HAS_TYPED_TEST 1 412#define GTEST_HAS_TYPED_TEST_P 1 413#endif // defined(__GNUC__) || (_MSC_VER >= 1400) && !defined(GTEST_OS_ANDROID) 414 415// Determines whether to support Combine(). This only makes sense when 416// value-parameterized tests are enabled. 417#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 418#define GTEST_HAS_COMBINE 1 419#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE 420 421// Determines whether the system compiler uses UTF-16 for encoding wide strings. 422#define GTEST_WIDE_STRING_USES_UTF16_ \ 423 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN) 424 425// Defines some utility macros. 426 427// The GNU compiler emits a warning if nested "if" statements are followed by 428// an "else" statement and braces are not used to explicitly disambiguate the 429// "else" binding. This leads to problems with code like: 430// 431// if (gate) 432// ASSERT_*(condition) << "Some message"; 433// 434// The "switch (0) case 0:" idiom is used to suppress this. 435#ifdef __INTEL_COMPILER 436#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 437#else 438#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: // NOLINT 439#endif 440 441// Use this annotation at the end of a struct / class definition to 442// prevent the compiler from optimizing away instances that are never 443// used. This is useful when all interesting logic happens inside the 444// c'tor and / or d'tor. Example: 445// 446// struct Foo { 447// Foo() { ... } 448// } GTEST_ATTRIBUTE_UNUSED_; 449#if defined(__GNUC__) && !defined(COMPILER_ICC) 450#define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 451#else 452#define GTEST_ATTRIBUTE_UNUSED_ 453#endif 454 455// A macro to disallow the evil copy constructor and operator= functions 456// This should be used in the private: declarations for a class. 457#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 458 type(const type &);\ 459 void operator=(const type &) 460 461// Tell the compiler to warn about unused return values for functions declared 462// with this macro. The macro should be used on function declarations 463// following the argument list: 464// 465// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; 466#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 467#define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 468#else 469#define GTEST_MUST_USE_RESULT_ 470#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 471 472namespace testing { 473 474class Message; 475 476namespace internal { 477 478class String; 479 480// std::strstream is deprecated. However, we have to use it on 481// Windows as std::stringstream won't compile on Windows when 482// exceptions are disabled. We use std::stringstream on other 483// platforms to avoid compiler warnings there. 484#if GTEST_HAS_STD_STRING 485typedef ::std::stringstream StrStream; 486#else 487typedef ::std::strstream StrStream; 488#endif // GTEST_HAS_STD_STRING 489 490// Defines scoped_ptr. 491 492// This implementation of scoped_ptr is PARTIAL - it only contains 493// enough stuff to satisfy Google Test's need. 494template <typename T> 495class scoped_ptr { 496 public: 497 explicit scoped_ptr(T* p = NULL) : ptr_(p) {} 498 ~scoped_ptr() { reset(); } 499 500 T& operator*() const { return *ptr_; } 501 T* operator->() const { return ptr_; } 502 T* get() const { return ptr_; } 503 504 T* release() { 505 T* const ptr = ptr_; 506 ptr_ = NULL; 507 return ptr; 508 } 509 510 void reset(T* p = NULL) { 511 if (p != ptr_) { 512 if (sizeof(T) > 0) { // Makes sure T is a complete type. 513 delete ptr_; 514 } 515 ptr_ = p; 516 } 517 } 518 private: 519 T* ptr_; 520 521 GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); 522}; 523 524// Defines RE. 525 526// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended 527// Regular Expression syntax. 528class RE { 529 public: 530 // Constructs an RE from a string. 531#if GTEST_HAS_STD_STRING 532 RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT 533#endif // GTEST_HAS_STD_STRING 534 535#if GTEST_HAS_GLOBAL_STRING 536 RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT 537#endif // GTEST_HAS_GLOBAL_STRING 538 539 RE(const char* regex) { Init(regex); } // NOLINT 540 ~RE(); 541 542 // Returns the string representation of the regex. 543 const char* pattern() const { return pattern_; } 544 545 // FullMatch(str, re) returns true iff regular expression re matches 546 // the entire str. 547 // PartialMatch(str, re) returns true iff regular expression re 548 // matches a substring of str (including str itself). 549 // 550 // TODO(wan@google.com): make FullMatch() and PartialMatch() work 551 // when str contains NUL characters. 552#if GTEST_HAS_STD_STRING 553 static bool FullMatch(const ::std::string& str, const RE& re) { 554 return FullMatch(str.c_str(), re); 555 } 556 static bool PartialMatch(const ::std::string& str, const RE& re) { 557 return PartialMatch(str.c_str(), re); 558 } 559#endif // GTEST_HAS_STD_STRING 560 561#if GTEST_HAS_GLOBAL_STRING 562 static bool FullMatch(const ::string& str, const RE& re) { 563 return FullMatch(str.c_str(), re); 564 } 565 static bool PartialMatch(const ::string& str, const RE& re) { 566 return PartialMatch(str.c_str(), re); 567 } 568#endif // GTEST_HAS_GLOBAL_STRING 569 570 static bool FullMatch(const char* str, const RE& re); 571 static bool PartialMatch(const char* str, const RE& re); 572 573 private: 574 void Init(const char* regex); 575 576 // We use a const char* instead of a string, as Google Test may be used 577 // where string is not available. We also do not use Google Test's own 578 // String type here, in order to simplify dependencies between the 579 // files. 580 const char* pattern_; 581 bool is_valid_; 582#if GTEST_USES_POSIX_RE 583 regex_t full_regex_; // For FullMatch(). 584 regex_t partial_regex_; // For PartialMatch(). 585#else // GTEST_USES_SIMPLE_RE 586 const char* full_pattern_; // For FullMatch(); 587#endif 588 589 GTEST_DISALLOW_COPY_AND_ASSIGN_(RE); 590}; 591 592// Defines logging utilities: 593// GTEST_LOG_() - logs messages at the specified severity level. 594// LogToStderr() - directs all log messages to stderr. 595// FlushInfoLog() - flushes informational log messages. 596 597enum GTestLogSeverity { 598 GTEST_INFO, 599 GTEST_WARNING, 600 GTEST_ERROR, 601 GTEST_FATAL 602}; 603 604void GTestLog(GTestLogSeverity severity, const char* file, 605 int line, const char* msg); 606 607#define GTEST_LOG_(severity, msg)\ 608 ::testing::internal::GTestLog(\ 609 ::testing::internal::GTEST_##severity, __FILE__, __LINE__, \ 610 (::testing::Message() << (msg)).GetString().c_str()) 611 612inline void LogToStderr() {} 613inline void FlushInfoLog() { fflush(NULL); } 614 615// Defines the stderr capturer: 616// CaptureStderr - starts capturing stderr. 617// GetCapturedStderr - stops capturing stderr and returns the captured string. 618 619#if GTEST_HAS_STD_STRING 620void CaptureStderr(); 621::std::string GetCapturedStderr(); 622#endif // GTEST_HAS_STD_STRING 623 624#if GTEST_HAS_DEATH_TEST 625 626// A copy of all command line arguments. Set by InitGoogleTest(). 627extern ::std::vector<String> g_argvs; 628 629// GTEST_HAS_DEATH_TEST implies we have ::std::string. 630const ::std::vector<String>& GetArgvs(); 631 632#endif // GTEST_HAS_DEATH_TEST 633 634// Defines synchronization primitives. 635 636// A dummy implementation of synchronization primitives (mutex, lock, 637// and thread-local variable). Necessary for compiling Google Test where 638// mutex is not supported - using Google Test in multiple threads is not 639// supported on such platforms. 640 641class Mutex { 642 public: 643 Mutex() {} 644 explicit Mutex(int /*unused*/) {} 645 void AssertHeld() const {} 646 enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 }; 647}; 648 649// We cannot call it MutexLock directly as the ctor declaration would 650// conflict with a macro named MutexLock, which is defined on some 651// platforms. Hence the typedef trick below. 652class GTestMutexLock { 653 public: 654 explicit GTestMutexLock(Mutex*) {} // NOLINT 655}; 656 657typedef GTestMutexLock MutexLock; 658 659template <typename T> 660class ThreadLocal { 661 public: 662 ThreadLocal() : value_() {} 663 explicit ThreadLocal(const T& value) : value_(value) {} 664 T* pointer() { return &value_; } 665 const T* pointer() const { return &value_; } 666 const T& get() const { return value_; } 667 void set(const T& value) { value_ = value; } 668 private: 669 T value_; 670}; 671 672// There's no portable way to detect the number of threads, so we just 673// return 0 to indicate that we cannot detect it. 674inline size_t GetThreadCount() { return 0; } 675 676// The above synchronization primitives have dummy implementations. 677// Therefore Google Test is not thread-safe. 678#define GTEST_IS_THREADSAFE 0 679 680#if defined(__SYMBIAN32__) || defined(__IBMCPP__) 681 682// Passing non-POD classes through ellipsis (...) crashes the ARM 683// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to 684// instantiate a copy constructor for objects passed through ellipsis 685// (...), failing for uncopyable objects. We define this to indicate 686// the fact. 687#define GTEST_ELLIPSIS_NEEDS_COPY_ 1 688 689// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between 690// const T& and const T* in a function template. These compilers 691// _can_ decide between class template specializations for T and T*, 692// so a tr1::type_traits-like is_pointer works. 693#define GTEST_NEEDS_IS_POINTER_ 1 694 695#endif // defined(__SYMBIAN32__) || defined(__IBMCPP__) 696 697template <bool bool_value> 698struct bool_constant { 699 typedef bool_constant<bool_value> type; 700 static const bool value = bool_value; 701}; 702template <bool bool_value> const bool bool_constant<bool_value>::value; 703 704typedef bool_constant<false> false_type; 705typedef bool_constant<true> true_type; 706 707template <typename T> 708struct is_pointer : public false_type {}; 709 710template <typename T> 711struct is_pointer<T*> : public true_type {}; 712 713#if GTEST_OS_WINDOWS 714#define GTEST_PATH_SEP_ "\\" 715#else 716#define GTEST_PATH_SEP_ "/" 717#endif // GTEST_OS_WINDOWS 718 719// Defines BiggestInt as the biggest signed integer type the compiler 720// supports. 721#if GTEST_OS_WINDOWS 722typedef __int64 BiggestInt; 723#else 724typedef long long BiggestInt; // NOLINT 725#endif // GTEST_OS_WINDOWS 726 727// The maximum number a BiggestInt can represent. This definition 728// works no matter BiggestInt is represented in one's complement or 729// two's complement. 730// 731// We cannot rely on numeric_limits in STL, as __int64 and long long 732// are not part of standard C++ and numeric_limits doesn't need to be 733// defined for them. 734const BiggestInt kMaxBiggestInt = 735 ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); 736 737// This template class serves as a compile-time function from size to 738// type. It maps a size in bytes to a primitive type with that 739// size. e.g. 740// 741// TypeWithSize<4>::UInt 742// 743// is typedef-ed to be unsigned int (unsigned integer made up of 4 744// bytes). 745// 746// Such functionality should belong to STL, but I cannot find it 747// there. 748// 749// Google Test uses this class in the implementation of floating-point 750// comparison. 751// 752// For now it only handles UInt (unsigned int) as that's all Google Test 753// needs. Other types can be easily added in the future if need 754// arises. 755template <size_t size> 756class TypeWithSize { 757 public: 758 // This prevents the user from using TypeWithSize<N> with incorrect 759 // values of N. 760 typedef void UInt; 761}; 762 763// The specialization for size 4. 764template <> 765class TypeWithSize<4> { 766 public: 767 // unsigned int has size 4 in both gcc and MSVC. 768 // 769 // As base/basictypes.h doesn't compile on Windows, we cannot use 770 // uint32, uint64, and etc here. 771 typedef int Int; 772 typedef unsigned int UInt; 773}; 774 775// The specialization for size 8. 776template <> 777class TypeWithSize<8> { 778 public: 779#if GTEST_OS_WINDOWS 780 typedef __int64 Int; 781 typedef unsigned __int64 UInt; 782#else 783 typedef long long Int; // NOLINT 784 typedef unsigned long long UInt; // NOLINT 785#endif // GTEST_OS_WINDOWS 786}; 787 788// Integer types of known sizes. 789typedef TypeWithSize<4>::Int Int32; 790typedef TypeWithSize<4>::UInt UInt32; 791typedef TypeWithSize<8>::Int Int64; 792typedef TypeWithSize<8>::UInt UInt64; 793typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. 794 795// Utilities for command line flags and environment variables. 796 797// A wrapper for getenv() that works on Linux, Windows, and Mac OS. 798inline const char* GetEnv(const char* name) { 799#ifdef _WIN32_WCE // We are on Windows CE. 800 // CE has no environment variables. 801 return NULL; 802#elif GTEST_OS_WINDOWS // We are on Windows proper. 803 // MSVC 8 deprecates getenv(), so we want to suppress warning 4996 804 // (deprecated function) there. 805#pragma warning(push) // Saves the current warning state. 806#pragma warning(disable:4996) // Temporarily disables warning 4996. 807 return getenv(name); 808#pragma warning(pop) // Restores the warning state. 809#else // We are on Linux or Mac OS. 810 return getenv(name); 811#endif 812} 813 814#ifdef _WIN32_WCE 815// Windows CE has no C library. The abort() function is used in 816// several places in Google Test. This implementation provides a reasonable 817// imitation of standard behaviour. 818void abort(); 819#else 820inline void abort() { ::abort(); } 821#endif // _WIN32_WCE 822 823// INTERNAL IMPLEMENTATION - DO NOT USE. 824// 825// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition 826// is not satisfied. 827// Synopsys: 828// GTEST_CHECK_(boolean_condition); 829// or 830// GTEST_CHECK_(boolean_condition) << "Additional message"; 831// 832// This checks the condition and if the condition is not satisfied 833// it prints message about the condition violation, including the 834// condition itself, plus additional message streamed into it, if any, 835// and then it aborts the program. It aborts the program irrespective of 836// whether it is built in the debug mode or not. 837class GTestCheckProvider { 838 public: 839 GTestCheckProvider(const char* condition, const char* file, int line) { 840 FormatFileLocation(file, line); 841 ::std::cerr << " ERROR: Condition " << condition << " failed. "; 842 } 843 ~GTestCheckProvider() { 844 ::std::cerr << ::std::endl; 845 abort(); 846 } 847 void FormatFileLocation(const char* file, int line) { 848 if (file == NULL) 849 file = "unknown file"; 850 if (line < 0) { 851 ::std::cerr << file << ":"; 852 } else { 853#if _MSC_VER 854 ::std::cerr << file << "(" << line << "):"; 855#else 856 ::std::cerr << file << ":" << line << ":"; 857#endif 858 } 859 } 860 ::std::ostream& GetStream() { return ::std::cerr; } 861}; 862#define GTEST_CHECK_(condition) \ 863 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 864 if (condition) \ 865 ; \ 866 else \ 867 ::testing::internal::GTestCheckProvider(\ 868 #condition, __FILE__, __LINE__).GetStream() 869 870// Macro for referencing flags. 871#define GTEST_FLAG(name) FLAGS_gtest_##name 872 873// Macros for declaring flags. 874#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name) 875#define GTEST_DECLARE_int32_(name) \ 876 extern ::testing::internal::Int32 GTEST_FLAG(name) 877#define GTEST_DECLARE_string_(name) \ 878 extern ::testing::internal::String GTEST_FLAG(name) 879 880// Macros for defining flags. 881#define GTEST_DEFINE_bool_(name, default_val, doc) \ 882 bool GTEST_FLAG(name) = (default_val) 883#define GTEST_DEFINE_int32_(name, default_val, doc) \ 884 ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 885#define GTEST_DEFINE_string_(name, default_val, doc) \ 886 ::testing::internal::String GTEST_FLAG(name) = (default_val) 887 888// Parses 'str' for a 32-bit signed integer. If successful, writes the result 889// to *value and returns true; otherwise leaves *value unchanged and returns 890// false. 891// TODO(chandlerc): Find a better way to refactor flag and environment parsing 892// out of both gtest-port.cc and gtest.cc to avoid exporting this utility 893// function. 894bool ParseInt32(const Message& src_text, const char* str, Int32* value); 895 896// Parses a bool/Int32/string from the environment variable 897// corresponding to the given Google Test flag. 898bool BoolFromGTestEnv(const char* flag, bool default_val); 899Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 900const char* StringFromGTestEnv(const char* flag, const char* default_val); 901 902} // namespace internal 903} // namespace testing 904 905#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 906