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 (at) 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 (at) 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 (at) 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 (at) 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 (at) 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 472 namespace testing { 473 474 class Message; 475 476 namespace internal { 477 478 class 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 485 typedef ::std::stringstream StrStream; 486 #else 487 typedef ::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. 494 template <typename T> 495 class 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. 528 class 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 (at) 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 597 enum GTestLogSeverity { 598 GTEST_INFO, 599 GTEST_WARNING, 600 GTEST_ERROR, 601 GTEST_FATAL 602 }; 603 604 void 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 612 inline void LogToStderr() {} 613 inline 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 620 void 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(). 627 extern ::std::vector<String> g_argvs; 628 629 // GTEST_HAS_DEATH_TEST implies we have ::std::string. 630 const ::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 641 class 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. 652 class GTestMutexLock { 653 public: 654 explicit GTestMutexLock(Mutex*) {} // NOLINT 655 }; 656 657 typedef GTestMutexLock MutexLock; 658 659 template <typename T> 660 class 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. 674 inline 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 697 template <bool bool_value> 698 struct bool_constant { 699 typedef bool_constant<bool_value> type; 700 static const bool value = bool_value; 701 }; 702 template <bool bool_value> const bool bool_constant<bool_value>::value; 703 704 typedef bool_constant<false> false_type; 705 typedef bool_constant<true> true_type; 706 707 template <typename T> 708 struct is_pointer : public false_type {}; 709 710 template <typename T> 711 struct 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 722 typedef __int64 BiggestInt; 723 #else 724 typedef 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. 734 const 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. 755 template <size_t size> 756 class 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. 764 template <> 765 class 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. 776 template <> 777 class 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. 789 typedef TypeWithSize<4>::Int Int32; 790 typedef TypeWithSize<4>::UInt UInt32; 791 typedef TypeWithSize<8>::Int Int64; 792 typedef TypeWithSize<8>::UInt UInt64; 793 typedef 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. 798 inline 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. 818 void abort(); 819 #else 820 inline 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. 837 class 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. 894 bool 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. 898 bool BoolFromGTestEnv(const char* flag, bool default_val); 899 Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); 900 const 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
